@strapi/admin 5.57.0 → 5.59.0

package/dist/admin/admin/src/translations/en.json.mjs

@@ -131,6 +131,9 @@ var en = {
     "Settings.adminTokens.editPage.title": "Edit Admin Token",
     "Settings.adminTokens.emptyStateLayout": "You don't have any content yet...",
     "Settings.adminTokens.title": "Admin Tokens",
+    "Settings.application.admin-seats": "Admin seats",
+    "Settings.application.ai-usage": "AI Usage",
+    "Settings.application.ai-usage.overage-rate": "+$1.50 per 100 credits above plan limit",
     "Settings.application.customization": "Customization",
     "Settings.application.customization.auth-logo.carousel-hint": "Replace the logo in the authentication pages",
     "Settings.application.customization.carousel-hint": "Change the admin panel logo (Max dimension: {dimension}x{dimension}, Max file size: {size}KB)",
@@ -162,20 +165,82 @@ var en = {
     "Settings.application.customization.modal.upload.next": "Next",
     "Settings.application.customization.size-details": "Max dimension: {dimension}×{dimension}, Max file size: {size}KB",
     "Settings.application.description": "Administration panel’s global information",
-    "Settings.application.ee.admin-seats.add-seats": "Manage subscription",
-    "Settings.application.ee.admin-seats.support": "Contact sales",
     "Settings.application.ee.admin-seats.at-limit-tooltip": "At limit: add seats to invite more users",
     "Settings.application.ee.admin-seats.count": "<text>{enforcementUserCount}</text>/{permittedSeats}",
     "Settings.application.get-help": "Get help",
-    "Settings.application.link-pricing": "See all pricing plans",
     "Settings.application.link-upgrade": "Upgrade your admin panel",
     "Settings.application.node-version": "node version",
-    "Settings.application.plan-title": "current plan",
+    "Settings.application.plan.current": "current plan",
+    "Settings.application.plan.manage-subscription": "Manage subscription",
+    "Settings.application.plan.see-all-plans": "See all plans",
+    "Settings.application.plan.title": "Plan",
+    "Settings.application.plan.view-subscription": "View subscription",
     "Settings.application.strapi-version": "Strapi version",
     "Settings.application.strapiVersion": "Strapi version",
+    "Settings.application.support.diagnostic-snapshot.description.community": "Reporting a bug? Generate a snapshot of your app's structure so the issue can be reproduced.",
+    "Settings.application.support.diagnostic-snapshot.description.enterprise": "Reporting a bug? A diagnostic snapshot describes how this project is built so it can be reproduced.",
+    "Settings.application.support.diagnostic-snapshot.generate": "Generate snapshot",
+    "Settings.application.support.diagnostic-snapshot.label": "diagnostic snapshot",
+    "Settings.application.support.discord.description": "Talk to the community in real time",
+    "Settings.application.support.discord.title": "Discord",
+    "Settings.application.support.documentation.description": "Guides and API reference",
+    "Settings.application.support.documentation.title": "Documentation",
+    "Settings.application.support.github-discussions.description": "Ask a question or propose an idea",
+    "Settings.application.support.github-discussions.title": "GitHub discussions",
+    "Settings.application.support.github-issues.description": "Report a bug",
+    "Settings.application.support.github-issues.title": "GitHub issues",
+    "Settings.application.support.subtitle.community": "Ask a question, report a bug, or contribute to the Strapi community.",
+    "Settings.application.support.subtitle.enterprise": "Contact support, report a bug, or contribute to the Strapi community.",
+    "Settings.application.support.support-portal.description": "Open a ticket with the Strapi support",
+    "Settings.application.support.support-portal.title": "Support portal",
+    "Settings.application.support.tile-label": "Open {title} in a new tab",
+    "Settings.application.support.title": "Support",
     "Settings.application.title": "Overview",
+    "Settings.debug-dump.copied": "Copied to clipboard",
+    "Settings.debug-dump.copy": "Copy",
+    "Settings.debug-dump.copy-failed": "Could not copy to clipboard",
+    "Settings.debug-dump.download": "Download",
+    "Settings.debug-dump.error": "Failed to generate the debug dump. Check the server logs and try again.",
+    "Settings.debug-dump.generating": "Generating diagnostic snapshot",
+    "Settings.debug-dump.payload-label": "payload",
+    "Settings.debug-dump.snapshot-modal.description": "This snapshot describes how your project is built so a third party can reproduce the bug locally. It does not contain any of your app's content and no credentials.",
+    "Settings.debug-dump.snapshot-modal.title": "Diagnostic snapshot",
     "Settings.error": "Error",
     "Settings.global": "Global Settings",
+    "Settings.license.checkin.never": "Not yet",
+    "Settings.license.entitlements": "plan entitlements",
+    "Settings.license.feature": "Feature",
+    "Settings.license.feature.audit-logs": "Audit Logs",
+    "Settings.license.feature.cms-advanced-preview": "Live Preview",
+    "Settings.license.feature.cms-content-history": "Content History",
+    "Settings.license.feature.cms-content-releases": "Releases",
+    "Settings.license.feature.review-workflows": "Review Workflows",
+    "Settings.license.feature.sso": "Single Sign-On",
+    "Settings.license.last-check": "Last license validity check {relative}",
+    "Settings.license.limit": "Limit",
+    "Settings.license.limit.count": "{value, number}",
+    "Settings.license.limit.days": "{days, plural, one {# day retention} other {# days retention}}",
+    "Settings.license.limit.maximumReleases": "Releases",
+    "Settings.license.limit.numberOfWorkflows": "Workflows",
+    "Settings.license.limit.retentionDays": "Retention",
+    "Settings.license.limit.stagesPerWorkflow": "Stages per workflow",
+    "Settings.license.limit.years": "~{years, plural, one {# year} other {# years}}",
+    "Settings.license.no": "No",
+    "Settings.license.registry.cached": "Couldn't reach the license registry. Showing the last license we retrieved.",
+    "Settings.license.registry.rejected": "The license registry could not validate this license.",
+    "Settings.license.registry.unreachable": "Couldn't reach the license registry.",
+    "Settings.license.renewal-date": "renewal date",
+    "Settings.license.status": "license status",
+    "Settings.license.status-tooltip": "Strapi checks the license status every 12 hours and on every build.",
+    "Settings.license.status.active": "Active",
+    "Settings.license.status.expired": "Expired",
+    "Settings.license.status.in-trial": "In Trial",
+    "Settings.license.status.unknown": "Unknown",
+    "Settings.license.subscription": "Subscription ID",
+    "Settings.license.trial-end-date": "trial end date",
+    "Settings.license.unlimited": "Unlimited",
+    "Settings.license.valid-until": "License valid until {date}",
+    "Settings.license.yes": "Yes",
     "Settings.permissions": "Administration panel",
     "Settings.permissions.auditLogs.action": "Action",
     "Settings.permissions.auditLogs.admin-user.create": "Create user",
@@ -185,6 +250,8 @@ var en = {
     "Settings.permissions.auditLogs.admin-user.password-reset.create": "Request password reset",
     "Settings.permissions.auditLogs.admin-user.password.update": "Update password",
     "Settings.permissions.auditLogs.admin-user.update": "Update user",
+    "Settings.permissions.auditLogs.admin.auth.autoRegistration": "SSO auto-registration",
+    "Settings.permissions.auditLogs.admin.auth.error": "Failed admin login",
     "Settings.permissions.auditLogs.admin.auth.success": "Admin login",
     "Settings.permissions.auditLogs.admin.logout": "Admin logout",
     "Settings.permissions.auditLogs.audit-log.export": "Export audit logs",

package/dist/admin/admin/src/translations/en.json.mjs.map

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

package/dist/admin/admin/src/translations/eu.json.js

@@ -98,7 +98,7 @@ var eu = {
     "Roles.RoleRow.select-all": "Hautatu {name} ekintza masiboetarako",
     "Roles.RoleRow.user-count": "{number, plural, =0 {#  user} one {#  user} other {# users}}",
     "Roles.components.List.empty.withSearch": "Ez dago bilaketari dagokion paperik ({search})...",
-    "Settings.PageTitle": "Konfigurazioa - {name}}",
+    "Settings.PageTitle": "Konfigurazioa - {name}",
     "Settings.apiTokens.addFirstToken": "Gehitu zure lehen API Token",
     "Settings.apiTokens.addNewToken": "Gehitu API Token berri bat",
     "Settings.tokens.copy.editMessage": "Segurtasun arrazoiengatik, behin bakarrik ikus dezakezu zure tokena",

package/dist/admin/admin/src/translations/eu.json.mjs

@@ -94,7 +94,7 @@ var eu = {
     "Roles.RoleRow.select-all": "Hautatu {name} ekintza masiboetarako",
     "Roles.RoleRow.user-count": "{number, plural, =0 {#  user} one {#  user} other {# users}}",
     "Roles.components.List.empty.withSearch": "Ez dago bilaketari dagokion paperik ({search})...",
-    "Settings.PageTitle": "Konfigurazioa - {name}}",
+    "Settings.PageTitle": "Konfigurazioa - {name}",
     "Settings.apiTokens.addFirstToken": "Gehitu zure lehen API Token",
     "Settings.apiTokens.addNewToken": "Gehitu API Token berri bat",
     "Settings.tokens.copy.editMessage": "Segurtasun arrazoiengatik, behin bakarrik ikus dezakezu zure tokena",

package/dist/admin/admin/src/utils/browserStrapi.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var getProjectType = require('./getProjectType.js');
+var getProjectType = require('../../../shared/utils/get-project-type.js');
 var urls = require('./urls.js');
 
 /**

package/dist/admin/admin/src/utils/browserStrapi.js.map

@@ -1 +1 @@
-{"version":3,"file":"browserStrapi.js","sources":["../../../../../admin/src/utils/browserStrapi.ts"],"sourcesContent":["import { getProjectType } from './getProjectType';\nimport { createAbsoluteUrl } from './urls';\n\nimport type { GetProjectType } from '../../../shared/contracts/admin';\nimport type { Modules } from '@strapi/types';\n\n/**\n * Builds the `window.strapi` object: Community defaults, then the license response.\n * Returned rather than assigned so the caller publishes it to `window` exactly once.\n *\n * Nothing here may read `window.strapi` — it does not exist yet, and the `#strapi`\n * mount node shadows it as a named window property, so reads silently yield the\n * element instead of throwing.\n */\nconst createBrowserStrapi = async (\n  features?: Modules.Features.FeaturesService['config']\n): Promise<Window['strapi']> => {\n  const browserStrapi: Window['strapi'] = {\n    /**\n     * This ENV variable is passed from the strapi instance, by default no url is set\n     * in the config and therefore the instance returns you an empty string so URLs are relative.\n     *\n     * To ensure that the backendURL is always set, we use the window.location.origin as a fallback.\n     */\n    backendURL: createAbsoluteUrl(process.env.STRAPI_ADMIN_BACKEND_URL),\n    isEE: false,\n    isTrial: false,\n    isTrialLicense: false,\n    telemetryDisabled: process.env.STRAPI_TELEMETRY_DISABLED === 'true',\n    future: {\n      isEnabled: (name: keyof NonNullable<Modules.Features.FeaturesConfig['future']>) => {\n        return features?.future?.[name] === true;\n      },\n    },\n    featureFlags: {\n      isEnabled: (name: keyof Omit<Modules.Features.FeaturesConfig, 'future'>) => {\n        return features?.[name] === true;\n      },\n    },\n    features: {\n      SSO: 'sso',\n      AUDIT_LOGS: 'audit-logs',\n      REVIEW_WORKFLOWS: 'review-workflows',\n      /**\n       * If we don't get the license then we know it's not EE\n       * so no feature is enabled.\n       */\n      isEnabled: () => false,\n    },\n    projectType: 'Community',\n    flags: {\n      nps: false,\n      promoteEE: true,\n      docLinks: true,\n    },\n    ai: {\n      enabled: false,\n    },\n  };\n\n  try {\n    /**\n     * Plain `fetch` rather than `getFetchClient`: the fetch client resolves its\n     * backend from `window.strapi`, which does not exist yet. The route is public,\n     * so it needs neither the auth header nor the token refresh the client adds.\n     */\n    const response = await fetch(`${browserStrapi.backendURL}/admin/project-type`, {\n      headers: { Accept: 'application/json' },\n    });\n\n    if (!response.ok) {\n      throw new Error(`[@strapi/admin]: /admin/project-type responded with ${response.status}`);\n    }\n\n    const {\n      data: { isEE, isTrial, features: licensedFeatures, flags, ai, planPriceId },\n    }: GetProjectType.Response = await response.json();\n\n    // Runtime defense: the payload is only typed by convention, not validated.\n    const trial = isTrial ?? false;\n\n    browserStrapi.isEE = isEE;\n    browserStrapi.isTrial = trial;\n    browserStrapi.isTrialLicense = trial;\n    browserStrapi.flags = flags;\n    browserStrapi.features = {\n      ...browserStrapi.features,\n      isEnabled: (featureName: string | undefined) =>\n        licensedFeatures.some((feature) => feature.name === featureName),\n    };\n    browserStrapi.projectType = getProjectType({ isEE, planPriceId });\n    browserStrapi.ai = ai;\n  } catch (err) {\n    /**\n     * If this fails, we simply don't activate any EE features.\n     * Should we warn clearer in the UI?\n     */\n    console.error(err);\n  }\n\n  return browserStrapi;\n};\n\nexport { createBrowserStrapi };\n"],"names":["createBrowserStrapi","features","browserStrapi","backendURL","createAbsoluteUrl","process","env","STRAPI_ADMIN_BACKEND_URL","isEE","isTrial","isTrialLicense","telemetryDisabled","STRAPI_TELEMETRY_DISABLED","future","isEnabled","name","featureFlags","SSO","AUDIT_LOGS","REVIEW_WORKFLOWS","projectType","flags","nps","promoteEE","docLinks","ai","enabled","response","fetch","headers","Accept","ok","Error","status","data","licensedFeatures","planPriceId","json","trial","featureName","some","feature","getProjectType","err","console","error"],"mappings":";;;;;AAMA;;;;;;;IAQA,MAAMA,sBAAsB,OAC1BC,QAAAA,GAAAA;AAEA,IAAA,MAAMC,aAAAA,GAAkC;AACtC;;;;;AAKC,QACDC,UAAAA,EAAYC,sBAAAA,CAAkBC,OAAAA,CAAQC,GAAG,CAACC,wBAAwB,CAAA;QAClEC,IAAAA,EAAM,KAAA;QACNC,OAAAA,EAAS,KAAA;QACTC,cAAAA,EAAgB,KAAA;AAChBC,QAAAA,iBAAAA,EAAmBN,OAAAA,CAAQC,GAAG,CAACM,yBAAyB,KAAK,MAAA;QAC7DC,MAAAA,EAAQ;AACNC,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;AACV,gBAAA,OAAOd,QAAAA,EAAUY,MAAAA,GAASE,IAAAA,CAAK,KAAK,IAAA;AACtC,YAAA;AACF,SAAA;QACAC,YAAAA,EAAc;AACZF,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;gBACV,OAAOd,QAAAA,GAAWc,IAAAA,CAAK,KAAK,IAAA;AAC9B,YAAA;AACF,SAAA;QACAd,QAAAA,EAAU;YACRgB,GAAAA,EAAK,KAAA;YACLC,UAAAA,EAAY,YAAA;YACZC,gBAAAA,EAAkB,kBAAA;AAClB;;;AAGC,UACDL,WAAW,IAAM;AACnB,SAAA;QACAM,WAAAA,EAAa,WAAA;QACbC,KAAAA,EAAO;YACLC,GAAAA,EAAK,KAAA;YACLC,SAAAA,EAAW,IAAA;YACXC,QAAAA,EAAU;AACZ,SAAA;QACAC,EAAAA,EAAI;YACFC,OAAAA,EAAS;AACX;AACF,KAAA;IAEA,IAAI;AACF;;;;QAKA,MAAMC,QAAAA,GAAW,MAAMC,KAAAA,CAAM,CAAA,EAAG1B,cAAcC,UAAU,CAAC,mBAAmB,CAAC,EAAE;YAC7E0B,OAAAA,EAAS;gBAAEC,MAAAA,EAAQ;AAAmB;AACxC,SAAA,CAAA;QAEA,IAAI,CAACH,QAAAA,CAASI,EAAE,EAAE;AAChB,YAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,oDAAoD,EAAEL,QAAAA,CAASM,MAAM,CAAA,CAAE,CAAA;AAC1F,QAAA;QAEA,MAAM,EACJC,MAAM,EAAE1B,IAAI,EAAEC,OAAO,EAAER,UAAUkC,gBAAgB,EAAEd,KAAK,EAAEI,EAAE,EAAEW,WAAW,EAAE,EAC5E,GAA4B,MAAMT,SAASU,IAAI,EAAA;;AAGhD,QAAA,MAAMC,QAAQ7B,OAAAA,IAAW,KAAA;AAEzBP,QAAAA,aAAAA,CAAcM,IAAI,GAAGA,IAAAA;AACrBN,QAAAA,aAAAA,CAAcO,OAAO,GAAG6B,KAAAA;AACxBpC,QAAAA,aAAAA,CAAcQ,cAAc,GAAG4B,KAAAA;AAC/BpC,QAAAA,aAAAA,CAAcmB,KAAK,GAAGA,KAAAA;AACtBnB,QAAAA,aAAAA,CAAcD,QAAQ,GAAG;AACvB,YAAA,GAAGC,cAAcD,QAAQ;YACzBa,SAAAA,EAAW,CAACyB,cACVJ,gBAAAA,CAAiBK,IAAI,CAAC,CAACC,OAAAA,GAAYA,OAAAA,CAAQ1B,IAAI,KAAKwB,WAAAA;AACxD,SAAA;QACArC,aAAAA,CAAckB,WAAW,GAAGsB,6BAAAA,CAAe;AAAElC,YAAAA,IAAAA;AAAM4B,YAAAA;AAAY,SAAA,CAAA;AAC/DlC,QAAAA,aAAAA,CAAcuB,EAAE,GAAGA,EAAAA;AACrB,IAAA,CAAA,CAAE,OAAOkB,GAAAA,EAAK;AACZ;;;QAIAC,OAAAA,CAAQC,KAAK,CAACF,GAAAA,CAAAA;AAChB,IAAA;IAEA,OAAOzC,aAAAA;AACT;;;;"}
+{"version":3,"file":"browserStrapi.js","sources":["../../../../../admin/src/utils/browserStrapi.ts"],"sourcesContent":["import { getProjectType } from '../../../shared/utils/get-project-type';\n\nimport { createAbsoluteUrl } from './urls';\n\nimport type { GetProjectType } from '../../../shared/contracts/admin';\nimport type { Modules } from '@strapi/types';\n\n/**\n * Builds the `window.strapi` object: Community defaults, then the license response.\n * Returned rather than assigned so the caller publishes it to `window` exactly once.\n *\n * Nothing here may read `window.strapi` — it does not exist yet, and the `#strapi`\n * mount node shadows it as a named window property, so reads silently yield the\n * element instead of throwing.\n */\nconst createBrowserStrapi = async (\n  features?: Modules.Features.FeaturesService['config']\n): Promise<Window['strapi']> => {\n  const browserStrapi: Window['strapi'] = {\n    /**\n     * This ENV variable is passed from the strapi instance, by default no url is set\n     * in the config and therefore the instance returns you an empty string so URLs are relative.\n     *\n     * To ensure that the backendURL is always set, we use the window.location.origin as a fallback.\n     */\n    backendURL: createAbsoluteUrl(process.env.STRAPI_ADMIN_BACKEND_URL),\n    isEE: false,\n    isTrial: false,\n    isTrialLicense: false,\n    telemetryDisabled: process.env.STRAPI_TELEMETRY_DISABLED === 'true',\n    future: {\n      isEnabled: (name: keyof NonNullable<Modules.Features.FeaturesConfig['future']>) => {\n        return features?.future?.[name] === true;\n      },\n    },\n    featureFlags: {\n      isEnabled: (name: keyof Omit<Modules.Features.FeaturesConfig, 'future'>) => {\n        return features?.[name] === true;\n      },\n    },\n    features: {\n      SSO: 'sso',\n      AUDIT_LOGS: 'audit-logs',\n      REVIEW_WORKFLOWS: 'review-workflows',\n      /**\n       * If we don't get the license then we know it's not EE\n       * so no feature is enabled.\n       */\n      isEnabled: () => false,\n    },\n    projectType: 'Community',\n    flags: {\n      nps: false,\n      promoteEE: true,\n      docLinks: true,\n    },\n    ai: {\n      enabled: false,\n    },\n  };\n\n  try {\n    /**\n     * Plain `fetch` rather than `getFetchClient`: the fetch client resolves its\n     * backend from `window.strapi`, which does not exist yet. The route is public,\n     * so it needs neither the auth header nor the token refresh the client adds.\n     */\n    const response = await fetch(`${browserStrapi.backendURL}/admin/project-type`, {\n      headers: { Accept: 'application/json' },\n    });\n\n    if (!response.ok) {\n      throw new Error(`[@strapi/admin]: /admin/project-type responded with ${response.status}`);\n    }\n\n    const {\n      data: { isEE, isTrial, features: licensedFeatures, flags, ai, planPriceId },\n    }: GetProjectType.Response = await response.json();\n\n    // Runtime defense: the payload is only typed by convention, not validated.\n    const trial = isTrial ?? false;\n\n    browserStrapi.isEE = isEE;\n    browserStrapi.isTrial = trial;\n    browserStrapi.isTrialLicense = trial;\n    browserStrapi.flags = flags;\n    browserStrapi.features = {\n      ...browserStrapi.features,\n      isEnabled: (featureName: string | undefined) =>\n        licensedFeatures.some((feature) => feature.name === featureName),\n    };\n    browserStrapi.projectType = getProjectType({ isEE, planPriceId });\n    browserStrapi.ai = ai;\n  } catch (err) {\n    /**\n     * If this fails, we simply don't activate any EE features.\n     * Should we warn clearer in the UI?\n     */\n    console.error(err);\n  }\n\n  return browserStrapi;\n};\n\nexport { createBrowserStrapi };\n"],"names":["createBrowserStrapi","features","browserStrapi","backendURL","createAbsoluteUrl","process","env","STRAPI_ADMIN_BACKEND_URL","isEE","isTrial","isTrialLicense","telemetryDisabled","STRAPI_TELEMETRY_DISABLED","future","isEnabled","name","featureFlags","SSO","AUDIT_LOGS","REVIEW_WORKFLOWS","projectType","flags","nps","promoteEE","docLinks","ai","enabled","response","fetch","headers","Accept","ok","Error","status","data","licensedFeatures","planPriceId","json","trial","featureName","some","feature","getProjectType","err","console","error"],"mappings":";;;;;AAOA;;;;;;;IAQA,MAAMA,sBAAsB,OAC1BC,QAAAA,GAAAA;AAEA,IAAA,MAAMC,aAAAA,GAAkC;AACtC;;;;;AAKC,QACDC,UAAAA,EAAYC,sBAAAA,CAAkBC,OAAAA,CAAQC,GAAG,CAACC,wBAAwB,CAAA;QAClEC,IAAAA,EAAM,KAAA;QACNC,OAAAA,EAAS,KAAA;QACTC,cAAAA,EAAgB,KAAA;AAChBC,QAAAA,iBAAAA,EAAmBN,OAAAA,CAAQC,GAAG,CAACM,yBAAyB,KAAK,MAAA;QAC7DC,MAAAA,EAAQ;AACNC,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;AACV,gBAAA,OAAOd,QAAAA,EAAUY,MAAAA,GAASE,IAAAA,CAAK,KAAK,IAAA;AACtC,YAAA;AACF,SAAA;QACAC,YAAAA,EAAc;AACZF,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;gBACV,OAAOd,QAAAA,GAAWc,IAAAA,CAAK,KAAK,IAAA;AAC9B,YAAA;AACF,SAAA;QACAd,QAAAA,EAAU;YACRgB,GAAAA,EAAK,KAAA;YACLC,UAAAA,EAAY,YAAA;YACZC,gBAAAA,EAAkB,kBAAA;AAClB;;;AAGC,UACDL,WAAW,IAAM;AACnB,SAAA;QACAM,WAAAA,EAAa,WAAA;QACbC,KAAAA,EAAO;YACLC,GAAAA,EAAK,KAAA;YACLC,SAAAA,EAAW,IAAA;YACXC,QAAAA,EAAU;AACZ,SAAA;QACAC,EAAAA,EAAI;YACFC,OAAAA,EAAS;AACX;AACF,KAAA;IAEA,IAAI;AACF;;;;QAKA,MAAMC,QAAAA,GAAW,MAAMC,KAAAA,CAAM,CAAA,EAAG1B,cAAcC,UAAU,CAAC,mBAAmB,CAAC,EAAE;YAC7E0B,OAAAA,EAAS;gBAAEC,MAAAA,EAAQ;AAAmB;AACxC,SAAA,CAAA;QAEA,IAAI,CAACH,QAAAA,CAASI,EAAE,EAAE;AAChB,YAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,oDAAoD,EAAEL,QAAAA,CAASM,MAAM,CAAA,CAAE,CAAA;AAC1F,QAAA;QAEA,MAAM,EACJC,MAAM,EAAE1B,IAAI,EAAEC,OAAO,EAAER,UAAUkC,gBAAgB,EAAEd,KAAK,EAAEI,EAAE,EAAEW,WAAW,EAAE,EAC5E,GAA4B,MAAMT,SAASU,IAAI,EAAA;;AAGhD,QAAA,MAAMC,QAAQ7B,OAAAA,IAAW,KAAA;AAEzBP,QAAAA,aAAAA,CAAcM,IAAI,GAAGA,IAAAA;AACrBN,QAAAA,aAAAA,CAAcO,OAAO,GAAG6B,KAAAA;AACxBpC,QAAAA,aAAAA,CAAcQ,cAAc,GAAG4B,KAAAA;AAC/BpC,QAAAA,aAAAA,CAAcmB,KAAK,GAAGA,KAAAA;AACtBnB,QAAAA,aAAAA,CAAcD,QAAQ,GAAG;AACvB,YAAA,GAAGC,cAAcD,QAAQ;YACzBa,SAAAA,EAAW,CAACyB,cACVJ,gBAAAA,CAAiBK,IAAI,CAAC,CAACC,OAAAA,GAAYA,OAAAA,CAAQ1B,IAAI,KAAKwB,WAAAA;AACxD,SAAA;QACArC,aAAAA,CAAckB,WAAW,GAAGsB,6BAAAA,CAAe;AAAElC,YAAAA,IAAAA;AAAM4B,YAAAA;AAAY,SAAA,CAAA;AAC/DlC,QAAAA,aAAAA,CAAcuB,EAAE,GAAGA,EAAAA;AACrB,IAAA,CAAA,CAAE,OAAOkB,GAAAA,EAAK;AACZ;;;QAIAC,OAAAA,CAAQC,KAAK,CAACF,GAAAA,CAAAA;AAChB,IAAA;IAEA,OAAOzC,aAAAA;AACT;;;;"}

package/dist/admin/admin/src/utils/browserStrapi.mjs

@@ -1,4 +1,4 @@
-import { getProjectType } from './getProjectType.mjs';
+import { getProjectType } from '../../../shared/utils/get-project-type.mjs';
 import { createAbsoluteUrl } from './urls.mjs';
 
 /**

package/dist/admin/admin/src/utils/browserStrapi.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"browserStrapi.mjs","sources":["../../../../../admin/src/utils/browserStrapi.ts"],"sourcesContent":["import { getProjectType } from './getProjectType';\nimport { createAbsoluteUrl } from './urls';\n\nimport type { GetProjectType } from '../../../shared/contracts/admin';\nimport type { Modules } from '@strapi/types';\n\n/**\n * Builds the `window.strapi` object: Community defaults, then the license response.\n * Returned rather than assigned so the caller publishes it to `window` exactly once.\n *\n * Nothing here may read `window.strapi` — it does not exist yet, and the `#strapi`\n * mount node shadows it as a named window property, so reads silently yield the\n * element instead of throwing.\n */\nconst createBrowserStrapi = async (\n  features?: Modules.Features.FeaturesService['config']\n): Promise<Window['strapi']> => {\n  const browserStrapi: Window['strapi'] = {\n    /**\n     * This ENV variable is passed from the strapi instance, by default no url is set\n     * in the config and therefore the instance returns you an empty string so URLs are relative.\n     *\n     * To ensure that the backendURL is always set, we use the window.location.origin as a fallback.\n     */\n    backendURL: createAbsoluteUrl(process.env.STRAPI_ADMIN_BACKEND_URL),\n    isEE: false,\n    isTrial: false,\n    isTrialLicense: false,\n    telemetryDisabled: process.env.STRAPI_TELEMETRY_DISABLED === 'true',\n    future: {\n      isEnabled: (name: keyof NonNullable<Modules.Features.FeaturesConfig['future']>) => {\n        return features?.future?.[name] === true;\n      },\n    },\n    featureFlags: {\n      isEnabled: (name: keyof Omit<Modules.Features.FeaturesConfig, 'future'>) => {\n        return features?.[name] === true;\n      },\n    },\n    features: {\n      SSO: 'sso',\n      AUDIT_LOGS: 'audit-logs',\n      REVIEW_WORKFLOWS: 'review-workflows',\n      /**\n       * If we don't get the license then we know it's not EE\n       * so no feature is enabled.\n       */\n      isEnabled: () => false,\n    },\n    projectType: 'Community',\n    flags: {\n      nps: false,\n      promoteEE: true,\n      docLinks: true,\n    },\n    ai: {\n      enabled: false,\n    },\n  };\n\n  try {\n    /**\n     * Plain `fetch` rather than `getFetchClient`: the fetch client resolves its\n     * backend from `window.strapi`, which does not exist yet. The route is public,\n     * so it needs neither the auth header nor the token refresh the client adds.\n     */\n    const response = await fetch(`${browserStrapi.backendURL}/admin/project-type`, {\n      headers: { Accept: 'application/json' },\n    });\n\n    if (!response.ok) {\n      throw new Error(`[@strapi/admin]: /admin/project-type responded with ${response.status}`);\n    }\n\n    const {\n      data: { isEE, isTrial, features: licensedFeatures, flags, ai, planPriceId },\n    }: GetProjectType.Response = await response.json();\n\n    // Runtime defense: the payload is only typed by convention, not validated.\n    const trial = isTrial ?? false;\n\n    browserStrapi.isEE = isEE;\n    browserStrapi.isTrial = trial;\n    browserStrapi.isTrialLicense = trial;\n    browserStrapi.flags = flags;\n    browserStrapi.features = {\n      ...browserStrapi.features,\n      isEnabled: (featureName: string | undefined) =>\n        licensedFeatures.some((feature) => feature.name === featureName),\n    };\n    browserStrapi.projectType = getProjectType({ isEE, planPriceId });\n    browserStrapi.ai = ai;\n  } catch (err) {\n    /**\n     * If this fails, we simply don't activate any EE features.\n     * Should we warn clearer in the UI?\n     */\n    console.error(err);\n  }\n\n  return browserStrapi;\n};\n\nexport { createBrowserStrapi };\n"],"names":["createBrowserStrapi","features","browserStrapi","backendURL","createAbsoluteUrl","process","env","STRAPI_ADMIN_BACKEND_URL","isEE","isTrial","isTrialLicense","telemetryDisabled","STRAPI_TELEMETRY_DISABLED","future","isEnabled","name","featureFlags","SSO","AUDIT_LOGS","REVIEW_WORKFLOWS","projectType","flags","nps","promoteEE","docLinks","ai","enabled","response","fetch","headers","Accept","ok","Error","status","data","licensedFeatures","planPriceId","json","trial","featureName","some","feature","getProjectType","err","console","error"],"mappings":";;;AAMA;;;;;;;IAQA,MAAMA,sBAAsB,OAC1BC,QAAAA,GAAAA;AAEA,IAAA,MAAMC,aAAAA,GAAkC;AACtC;;;;;AAKC,QACDC,UAAAA,EAAYC,iBAAAA,CAAkBC,OAAAA,CAAQC,GAAG,CAACC,wBAAwB,CAAA;QAClEC,IAAAA,EAAM,KAAA;QACNC,OAAAA,EAAS,KAAA;QACTC,cAAAA,EAAgB,KAAA;AAChBC,QAAAA,iBAAAA,EAAmBN,OAAAA,CAAQC,GAAG,CAACM,yBAAyB,KAAK,MAAA;QAC7DC,MAAAA,EAAQ;AACNC,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;AACV,gBAAA,OAAOd,QAAAA,EAAUY,MAAAA,GAASE,IAAAA,CAAK,KAAK,IAAA;AACtC,YAAA;AACF,SAAA;QACAC,YAAAA,EAAc;AACZF,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;gBACV,OAAOd,QAAAA,GAAWc,IAAAA,CAAK,KAAK,IAAA;AAC9B,YAAA;AACF,SAAA;QACAd,QAAAA,EAAU;YACRgB,GAAAA,EAAK,KAAA;YACLC,UAAAA,EAAY,YAAA;YACZC,gBAAAA,EAAkB,kBAAA;AAClB;;;AAGC,UACDL,WAAW,IAAM;AACnB,SAAA;QACAM,WAAAA,EAAa,WAAA;QACbC,KAAAA,EAAO;YACLC,GAAAA,EAAK,KAAA;YACLC,SAAAA,EAAW,IAAA;YACXC,QAAAA,EAAU;AACZ,SAAA;QACAC,EAAAA,EAAI;YACFC,OAAAA,EAAS;AACX;AACF,KAAA;IAEA,IAAI;AACF;;;;QAKA,MAAMC,QAAAA,GAAW,MAAMC,KAAAA,CAAM,CAAA,EAAG1B,cAAcC,UAAU,CAAC,mBAAmB,CAAC,EAAE;YAC7E0B,OAAAA,EAAS;gBAAEC,MAAAA,EAAQ;AAAmB;AACxC,SAAA,CAAA;QAEA,IAAI,CAACH,QAAAA,CAASI,EAAE,EAAE;AAChB,YAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,oDAAoD,EAAEL,QAAAA,CAASM,MAAM,CAAA,CAAE,CAAA;AAC1F,QAAA;QAEA,MAAM,EACJC,MAAM,EAAE1B,IAAI,EAAEC,OAAO,EAAER,UAAUkC,gBAAgB,EAAEd,KAAK,EAAEI,EAAE,EAAEW,WAAW,EAAE,EAC5E,GAA4B,MAAMT,SAASU,IAAI,EAAA;;AAGhD,QAAA,MAAMC,QAAQ7B,OAAAA,IAAW,KAAA;AAEzBP,QAAAA,aAAAA,CAAcM,IAAI,GAAGA,IAAAA;AACrBN,QAAAA,aAAAA,CAAcO,OAAO,GAAG6B,KAAAA;AACxBpC,QAAAA,aAAAA,CAAcQ,cAAc,GAAG4B,KAAAA;AAC/BpC,QAAAA,aAAAA,CAAcmB,KAAK,GAAGA,KAAAA;AACtBnB,QAAAA,aAAAA,CAAcD,QAAQ,GAAG;AACvB,YAAA,GAAGC,cAAcD,QAAQ;YACzBa,SAAAA,EAAW,CAACyB,cACVJ,gBAAAA,CAAiBK,IAAI,CAAC,CAACC,OAAAA,GAAYA,OAAAA,CAAQ1B,IAAI,KAAKwB,WAAAA;AACxD,SAAA;QACArC,aAAAA,CAAckB,WAAW,GAAGsB,cAAAA,CAAe;AAAElC,YAAAA,IAAAA;AAAM4B,YAAAA;AAAY,SAAA,CAAA;AAC/DlC,QAAAA,aAAAA,CAAcuB,EAAE,GAAGA,EAAAA;AACrB,IAAA,CAAA,CAAE,OAAOkB,GAAAA,EAAK;AACZ;;;QAIAC,OAAAA,CAAQC,KAAK,CAACF,GAAAA,CAAAA;AAChB,IAAA;IAEA,OAAOzC,aAAAA;AACT;;;;"}
+{"version":3,"file":"browserStrapi.mjs","sources":["../../../../../admin/src/utils/browserStrapi.ts"],"sourcesContent":["import { getProjectType } from '../../../shared/utils/get-project-type';\n\nimport { createAbsoluteUrl } from './urls';\n\nimport type { GetProjectType } from '../../../shared/contracts/admin';\nimport type { Modules } from '@strapi/types';\n\n/**\n * Builds the `window.strapi` object: Community defaults, then the license response.\n * Returned rather than assigned so the caller publishes it to `window` exactly once.\n *\n * Nothing here may read `window.strapi` — it does not exist yet, and the `#strapi`\n * mount node shadows it as a named window property, so reads silently yield the\n * element instead of throwing.\n */\nconst createBrowserStrapi = async (\n  features?: Modules.Features.FeaturesService['config']\n): Promise<Window['strapi']> => {\n  const browserStrapi: Window['strapi'] = {\n    /**\n     * This ENV variable is passed from the strapi instance, by default no url is set\n     * in the config and therefore the instance returns you an empty string so URLs are relative.\n     *\n     * To ensure that the backendURL is always set, we use the window.location.origin as a fallback.\n     */\n    backendURL: createAbsoluteUrl(process.env.STRAPI_ADMIN_BACKEND_URL),\n    isEE: false,\n    isTrial: false,\n    isTrialLicense: false,\n    telemetryDisabled: process.env.STRAPI_TELEMETRY_DISABLED === 'true',\n    future: {\n      isEnabled: (name: keyof NonNullable<Modules.Features.FeaturesConfig['future']>) => {\n        return features?.future?.[name] === true;\n      },\n    },\n    featureFlags: {\n      isEnabled: (name: keyof Omit<Modules.Features.FeaturesConfig, 'future'>) => {\n        return features?.[name] === true;\n      },\n    },\n    features: {\n      SSO: 'sso',\n      AUDIT_LOGS: 'audit-logs',\n      REVIEW_WORKFLOWS: 'review-workflows',\n      /**\n       * If we don't get the license then we know it's not EE\n       * so no feature is enabled.\n       */\n      isEnabled: () => false,\n    },\n    projectType: 'Community',\n    flags: {\n      nps: false,\n      promoteEE: true,\n      docLinks: true,\n    },\n    ai: {\n      enabled: false,\n    },\n  };\n\n  try {\n    /**\n     * Plain `fetch` rather than `getFetchClient`: the fetch client resolves its\n     * backend from `window.strapi`, which does not exist yet. The route is public,\n     * so it needs neither the auth header nor the token refresh the client adds.\n     */\n    const response = await fetch(`${browserStrapi.backendURL}/admin/project-type`, {\n      headers: { Accept: 'application/json' },\n    });\n\n    if (!response.ok) {\n      throw new Error(`[@strapi/admin]: /admin/project-type responded with ${response.status}`);\n    }\n\n    const {\n      data: { isEE, isTrial, features: licensedFeatures, flags, ai, planPriceId },\n    }: GetProjectType.Response = await response.json();\n\n    // Runtime defense: the payload is only typed by convention, not validated.\n    const trial = isTrial ?? false;\n\n    browserStrapi.isEE = isEE;\n    browserStrapi.isTrial = trial;\n    browserStrapi.isTrialLicense = trial;\n    browserStrapi.flags = flags;\n    browserStrapi.features = {\n      ...browserStrapi.features,\n      isEnabled: (featureName: string | undefined) =>\n        licensedFeatures.some((feature) => feature.name === featureName),\n    };\n    browserStrapi.projectType = getProjectType({ isEE, planPriceId });\n    browserStrapi.ai = ai;\n  } catch (err) {\n    /**\n     * If this fails, we simply don't activate any EE features.\n     * Should we warn clearer in the UI?\n     */\n    console.error(err);\n  }\n\n  return browserStrapi;\n};\n\nexport { createBrowserStrapi };\n"],"names":["createBrowserStrapi","features","browserStrapi","backendURL","createAbsoluteUrl","process","env","STRAPI_ADMIN_BACKEND_URL","isEE","isTrial","isTrialLicense","telemetryDisabled","STRAPI_TELEMETRY_DISABLED","future","isEnabled","name","featureFlags","SSO","AUDIT_LOGS","REVIEW_WORKFLOWS","projectType","flags","nps","promoteEE","docLinks","ai","enabled","response","fetch","headers","Accept","ok","Error","status","data","licensedFeatures","planPriceId","json","trial","featureName","some","feature","getProjectType","err","console","error"],"mappings":";;;AAOA;;;;;;;IAQA,MAAMA,sBAAsB,OAC1BC,QAAAA,GAAAA;AAEA,IAAA,MAAMC,aAAAA,GAAkC;AACtC;;;;;AAKC,QACDC,UAAAA,EAAYC,iBAAAA,CAAkBC,OAAAA,CAAQC,GAAG,CAACC,wBAAwB,CAAA;QAClEC,IAAAA,EAAM,KAAA;QACNC,OAAAA,EAAS,KAAA;QACTC,cAAAA,EAAgB,KAAA;AAChBC,QAAAA,iBAAAA,EAAmBN,OAAAA,CAAQC,GAAG,CAACM,yBAAyB,KAAK,MAAA;QAC7DC,MAAAA,EAAQ;AACNC,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;AACV,gBAAA,OAAOd,QAAAA,EAAUY,MAAAA,GAASE,IAAAA,CAAK,KAAK,IAAA;AACtC,YAAA;AACF,SAAA;QACAC,YAAAA,EAAc;AACZF,YAAAA,SAAAA,EAAW,CAACC,IAAAA,GAAAA;gBACV,OAAOd,QAAAA,GAAWc,IAAAA,CAAK,KAAK,IAAA;AAC9B,YAAA;AACF,SAAA;QACAd,QAAAA,EAAU;YACRgB,GAAAA,EAAK,KAAA;YACLC,UAAAA,EAAY,YAAA;YACZC,gBAAAA,EAAkB,kBAAA;AAClB;;;AAGC,UACDL,WAAW,IAAM;AACnB,SAAA;QACAM,WAAAA,EAAa,WAAA;QACbC,KAAAA,EAAO;YACLC,GAAAA,EAAK,KAAA;YACLC,SAAAA,EAAW,IAAA;YACXC,QAAAA,EAAU;AACZ,SAAA;QACAC,EAAAA,EAAI;YACFC,OAAAA,EAAS;AACX;AACF,KAAA;IAEA,IAAI;AACF;;;;QAKA,MAAMC,QAAAA,GAAW,MAAMC,KAAAA,CAAM,CAAA,EAAG1B,cAAcC,UAAU,CAAC,mBAAmB,CAAC,EAAE;YAC7E0B,OAAAA,EAAS;gBAAEC,MAAAA,EAAQ;AAAmB;AACxC,SAAA,CAAA;QAEA,IAAI,CAACH,QAAAA,CAASI,EAAE,EAAE;AAChB,YAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,oDAAoD,EAAEL,QAAAA,CAASM,MAAM,CAAA,CAAE,CAAA;AAC1F,QAAA;QAEA,MAAM,EACJC,MAAM,EAAE1B,IAAI,EAAEC,OAAO,EAAER,UAAUkC,gBAAgB,EAAEd,KAAK,EAAEI,EAAE,EAAEW,WAAW,EAAE,EAC5E,GAA4B,MAAMT,SAASU,IAAI,EAAA;;AAGhD,QAAA,MAAMC,QAAQ7B,OAAAA,IAAW,KAAA;AAEzBP,QAAAA,aAAAA,CAAcM,IAAI,GAAGA,IAAAA;AACrBN,QAAAA,aAAAA,CAAcO,OAAO,GAAG6B,KAAAA;AACxBpC,QAAAA,aAAAA,CAAcQ,cAAc,GAAG4B,KAAAA;AAC/BpC,QAAAA,aAAAA,CAAcmB,KAAK,GAAGA,KAAAA;AACtBnB,QAAAA,aAAAA,CAAcD,QAAQ,GAAG;AACvB,YAAA,GAAGC,cAAcD,QAAQ;YACzBa,SAAAA,EAAW,CAACyB,cACVJ,gBAAAA,CAAiBK,IAAI,CAAC,CAACC,OAAAA,GAAYA,OAAAA,CAAQ1B,IAAI,KAAKwB,WAAAA;AACxD,SAAA;QACArC,aAAAA,CAAckB,WAAW,GAAGsB,cAAAA,CAAe;AAAElC,YAAAA,IAAAA;AAAM4B,YAAAA;AAAY,SAAA,CAAA;AAC/DlC,QAAAA,aAAAA,CAAcuB,EAAE,GAAGA,EAAAA;AACrB,IAAA,CAAA,CAAE,OAAOkB,GAAAA,EAAK;AACZ;;;QAIAC,OAAAA,CAAQC,KAAK,CAACF,GAAAA,CAAAA;AAChB,IAAA;IAEA,OAAOzC,aAAAA;AACT;;;;"}

package/dist/admin/admin/src/utils/cookies.js

@@ -9,8 +9,9 @@ var authCookiePath = require('../../../shared/utils/auth-cookie-path.js');
  * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_NAME`.
  */ const AUTH_COOKIE_NAME = authCookieName.resolveAuthCookieName(process.env.STRAPI_ADMIN_AUTH_COOKIE_NAME);
 /**
- * Resolved once at module load: the build inlines `admin.auth.cookie.path`
- * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_PATH`.
+ * Resolved once at module load: the build inlines `admin.auth.cookie.path`,
+ * or the path the panel is served from when it is unset, into the bundle as
+ * `STRAPI_ADMIN_AUTH_COOKIE_PATH`.
  */ const AUTH_COOKIE_PATH = authCookiePath.resolveAuthCookiePath(process.env.STRAPI_ADMIN_AUTH_COOKIE_PATH);
 /**
  * Resolved once at module load: the build inlines `admin.auth.cookie.domain`
@@ -67,10 +68,10 @@ const expireCookieAt = (name, path, domain)=>{
 };
 /**
  * Sets a cookie with the given name, value, and optional expiration time.
- * Uses `admin.auth.cookie.path` and `admin.auth.cookie.domain` (both inlined
- * at build time) so the access cookie stays scoped to the same path and domain
- * as the httpOnly refresh cookie and the EE SSO access cookie. The cookie is
- * marked `Secure` whenever the page is served over TLS.
+ * Uses the access cookie path and `admin.auth.cookie.domain` (both inlined at
+ * build time) so the cookie lands on the same path and domain as the EE SSO
+ * access cookie written by the server. The cookie is marked `Secure` whenever
+ * the page is served over TLS.
  *
  * @param name - The name of the cookie.
  * @param value - The value of the cookie.

package/dist/admin/admin/src/utils/cookies.js.map

@@ -1 +1 @@
-{"version":3,"file":"cookies.js","sources":["../../../../../admin/src/utils/cookies.ts"],"sourcesContent":["import { resolveAuthCookieDomain } from '../../../shared/utils/auth-cookie-domain';\nimport { resolveAuthCookieName } from '../../../shared/utils/auth-cookie-name';\nimport { resolveAuthCookiePath } from '../../../shared/utils/auth-cookie-path';\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.name`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_NAME`.\n */\nexport const AUTH_COOKIE_NAME = resolveAuthCookieName(process.env.STRAPI_ADMIN_AUTH_COOKIE_NAME);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.path`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_PATH`.\n */\nexport const AUTH_COOKIE_PATH = resolveAuthCookiePath(process.env.STRAPI_ADMIN_AUTH_COOKIE_PATH);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.domain`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_DOMAIN`. `undefined` means the\n * cookie is host-only.\n */\nexport const AUTH_COOKIE_DOMAIN = resolveAuthCookieDomain(\n  process.env.STRAPI_ADMIN_AUTH_COOKIE_DOMAIN\n);\n\n/** Paths previously used by the client for the access cookie; cleared on set/delete. */\nconst LEGACY_AUTH_COOKIE_PATHS = ['/'] as const;\n\nconst expireCookieAt = (name: string, path: string, domain?: string): void => {\n  const domainAttr = domain ? `; Domain=${domain}` : '';\n  document.cookie = `${name}=; Path=${path}${domainAttr}; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;\n};\n\n/**\n * Every `(path, domain)` key the access cookie may live under: the configured\n * key plus the legacy-path and host-only variants written by older versions or\n * previous configs. The browser cookie store keys entries by\n * `(name, domain, path)`, so each combination is a distinct entry.\n */\nconst cookieKeyMatrix = (): Array<{ path: string; domain: string | undefined }> => {\n  const paths = new Set<string>([AUTH_COOKIE_PATH, ...LEGACY_AUTH_COOKIE_PATHS]);\n  const domains = new Set<string | undefined>([undefined, AUTH_COOKIE_DOMAIN]);\n\n  const matrix: Array<{ path: string; domain: string | undefined }> = [];\n  for (const path of paths) {\n    for (const domain of domains) {\n      matrix.push({ path, domain });\n    }\n  }\n  return matrix;\n};\n\n/**\n * Retrieves the value of a specified cookie.\n *\n * @param name - The name of the cookie to retrieve.\n * @returns The decoded cookie value if found, otherwise null.\n */\nexport const getCookieValue = (name: string): string | null => {\n  let result = null;\n  const cookieArray = document.cookie.split(';');\n  cookieArray.forEach((cookie) => {\n    const [key, value] = cookie.split('=').map((item) => item.trim());\n    if (key === name) {\n      result = decodeURIComponent(value);\n    }\n  });\n  return result;\n};\n\n/**\n * Sets a cookie with the given name, value, and optional expiration time.\n * Uses `admin.auth.cookie.path` and `admin.auth.cookie.domain` (both inlined\n * at build time) so the access cookie stays scoped to the same path and domain\n * as the httpOnly refresh cookie and the EE SSO access cookie. The cookie is\n * marked `Secure` whenever the page is served over TLS.\n *\n * @param name - The name of the cookie.\n * @param value - The value of the cookie.\n * @param days - (Optional) Number of days until the cookie expires. If omitted, the cookie is a session cookie.\n */\nexport const setCookie = (name: string, value: string, days?: number): void => {\n  let expires = '';\n  if (days) {\n    const date = new Date();\n    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);\n    expires = `; Expires=${date.toUTCString()}`;\n  }\n\n  // Expire every other key the cookie may live under (legacy Path=/, host-only\n  // copies written before a domain was configured). A stale same-name entry at\n  // an equal-length path sorts first in document.cookie by creation time\n  // (RFC 6265 §5.4), so leaving one behind would shadow the token written below.\n  for (const { path, domain } of cookieKeyMatrix()) {\n    if (path !== AUTH_COOKIE_PATH || domain !== AUTH_COOKIE_DOMAIN) {\n      expireCookieAt(name, path, domain);\n    }\n  }\n\n  const domainAttr = AUTH_COOKIE_DOMAIN ? `; Domain=${AUTH_COOKIE_DOMAIN}` : '';\n  // Mark the token Secure when the page itself is served over TLS — the\n  // browser's own criterion — so it is never attached to plain-http requests.\n  // Expiry writes stay flag-free on purpose: deletion targets the (name,\n  // domain, path) key regardless of Secure, and from an http origin a\n  // flag-free write can still clear non-Secure entries (no origin can carry\n  // the Secure flag over http, and Secure entries are untouchable from there\n  // either way).\n  const secureAttr = window.location.protocol === 'https:' ? '; Secure' : '';\n  document.cookie = `${name}=${encodeURIComponent(value)}; Path=${AUTH_COOKIE_PATH}${domainAttr}${expires}${secureAttr}`;\n};\n\n/**\n * Deletes a cookie by setting its expiration date to a past date.\n *\n * Expires every combination of {configured path, legacy Path=/} and\n * {configured domain, host-only}. A `Domain`-scoped cookie is a distinct entry\n * from a host-only one in the browser cookie store, so both must be cleared or\n * remote logout leaves the EE SSO cookie (written with `Domain` by the server)\n * behind, rehydrating a dead session into an infinite login redirect.\n *\n * @param name - The name of the cookie to delete.\n */\nexport const deleteCookie = (name: string): void => {\n  for (const { path, domain } of cookieKeyMatrix()) {\n    expireCookieAt(name, path, domain);\n  }\n};\n"],"names":["AUTH_COOKIE_NAME","resolveAuthCookieName","process","env","STRAPI_ADMIN_AUTH_COOKIE_NAME","AUTH_COOKIE_PATH","resolveAuthCookiePath","STRAPI_ADMIN_AUTH_COOKIE_PATH","AUTH_COOKIE_DOMAIN","resolveAuthCookieDomain","STRAPI_ADMIN_AUTH_COOKIE_DOMAIN","LEGACY_AUTH_COOKIE_PATHS","expireCookieAt","name","path","domain","domainAttr","document","cookie","cookieKeyMatrix","paths","Set","domains","undefined","matrix","push","getCookieValue","result","cookieArray","split","forEach","key","value","map","item","trim","decodeURIComponent","setCookie","days","expires","secureAttr","window","location","protocol","encodeURIComponent","deleteCookie"],"mappings":"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"}
+{"version":3,"file":"cookies.js","sources":["../../../../../admin/src/utils/cookies.ts"],"sourcesContent":["import { resolveAuthCookieDomain } from '../../../shared/utils/auth-cookie-domain';\nimport { resolveAuthCookieName } from '../../../shared/utils/auth-cookie-name';\nimport { resolveAuthCookiePath } from '../../../shared/utils/auth-cookie-path';\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.name`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_NAME`.\n */\nexport const AUTH_COOKIE_NAME = resolveAuthCookieName(process.env.STRAPI_ADMIN_AUTH_COOKIE_NAME);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.path`,\n * or the path the panel is served from when it is unset, into the bundle as\n * `STRAPI_ADMIN_AUTH_COOKIE_PATH`.\n */\nexport const AUTH_COOKIE_PATH = resolveAuthCookiePath(process.env.STRAPI_ADMIN_AUTH_COOKIE_PATH);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.domain`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_DOMAIN`. `undefined` means the\n * cookie is host-only.\n */\nexport const AUTH_COOKIE_DOMAIN = resolveAuthCookieDomain(\n  process.env.STRAPI_ADMIN_AUTH_COOKIE_DOMAIN\n);\n\n/** Paths previously used by the client for the access cookie; cleared on set/delete. */\nconst LEGACY_AUTH_COOKIE_PATHS = ['/'] as const;\n\nconst expireCookieAt = (name: string, path: string, domain?: string): void => {\n  const domainAttr = domain ? `; Domain=${domain}` : '';\n  document.cookie = `${name}=; Path=${path}${domainAttr}; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;\n};\n\n/**\n * Every `(path, domain)` key the access cookie may live under: the configured\n * key plus the legacy-path and host-only variants written by older versions or\n * previous configs. The browser cookie store keys entries by\n * `(name, domain, path)`, so each combination is a distinct entry.\n */\nconst cookieKeyMatrix = (): Array<{ path: string; domain: string | undefined }> => {\n  const paths = new Set<string>([AUTH_COOKIE_PATH, ...LEGACY_AUTH_COOKIE_PATHS]);\n  const domains = new Set<string | undefined>([undefined, AUTH_COOKIE_DOMAIN]);\n\n  const matrix: Array<{ path: string; domain: string | undefined }> = [];\n  for (const path of paths) {\n    for (const domain of domains) {\n      matrix.push({ path, domain });\n    }\n  }\n  return matrix;\n};\n\n/**\n * Retrieves the value of a specified cookie.\n *\n * @param name - The name of the cookie to retrieve.\n * @returns The decoded cookie value if found, otherwise null.\n */\nexport const getCookieValue = (name: string): string | null => {\n  let result = null;\n  const cookieArray = document.cookie.split(';');\n  cookieArray.forEach((cookie) => {\n    const [key, value] = cookie.split('=').map((item) => item.trim());\n    if (key === name) {\n      result = decodeURIComponent(value);\n    }\n  });\n  return result;\n};\n\n/**\n * Sets a cookie with the given name, value, and optional expiration time.\n * Uses the access cookie path and `admin.auth.cookie.domain` (both inlined at\n * build time) so the cookie lands on the same path and domain as the EE SSO\n * access cookie written by the server. The cookie is marked `Secure` whenever\n * the page is served over TLS.\n *\n * @param name - The name of the cookie.\n * @param value - The value of the cookie.\n * @param days - (Optional) Number of days until the cookie expires. If omitted, the cookie is a session cookie.\n */\nexport const setCookie = (name: string, value: string, days?: number): void => {\n  let expires = '';\n  if (days) {\n    const date = new Date();\n    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);\n    expires = `; Expires=${date.toUTCString()}`;\n  }\n\n  // Expire every other key the cookie may live under (legacy Path=/, host-only\n  // copies written before a domain was configured). A stale same-name entry at\n  // an equal-length path sorts first in document.cookie by creation time\n  // (RFC 6265 §5.4), so leaving one behind would shadow the token written below.\n  for (const { path, domain } of cookieKeyMatrix()) {\n    if (path !== AUTH_COOKIE_PATH || domain !== AUTH_COOKIE_DOMAIN) {\n      expireCookieAt(name, path, domain);\n    }\n  }\n\n  const domainAttr = AUTH_COOKIE_DOMAIN ? `; Domain=${AUTH_COOKIE_DOMAIN}` : '';\n  // Mark the token Secure when the page itself is served over TLS — the\n  // browser's own criterion — so it is never attached to plain-http requests.\n  // Expiry writes stay flag-free on purpose: deletion targets the (name,\n  // domain, path) key regardless of Secure, and from an http origin a\n  // flag-free write can still clear non-Secure entries (no origin can carry\n  // the Secure flag over http, and Secure entries are untouchable from there\n  // either way).\n  const secureAttr = window.location.protocol === 'https:' ? '; Secure' : '';\n  document.cookie = `${name}=${encodeURIComponent(value)}; Path=${AUTH_COOKIE_PATH}${domainAttr}${expires}${secureAttr}`;\n};\n\n/**\n * Deletes a cookie by setting its expiration date to a past date.\n *\n * Expires every combination of {configured path, legacy Path=/} and\n * {configured domain, host-only}. A `Domain`-scoped cookie is a distinct entry\n * from a host-only one in the browser cookie store, so both must be cleared or\n * remote logout leaves the EE SSO cookie (written with `Domain` by the server)\n * behind, rehydrating a dead session into an infinite login redirect.\n *\n * @param name - The name of the cookie to delete.\n */\nexport const deleteCookie = (name: string): void => {\n  for (const { path, domain } of cookieKeyMatrix()) {\n    expireCookieAt(name, path, domain);\n  }\n};\n"],"names":["AUTH_COOKIE_NAME","resolveAuthCookieName","process","env","STRAPI_ADMIN_AUTH_COOKIE_NAME","AUTH_COOKIE_PATH","resolveAuthCookiePath","STRAPI_ADMIN_AUTH_COOKIE_PATH","AUTH_COOKIE_DOMAIN","resolveAuthCookieDomain","STRAPI_ADMIN_AUTH_COOKIE_DOMAIN","LEGACY_AUTH_COOKIE_PATHS","expireCookieAt","name","path","domain","domainAttr","document","cookie","cookieKeyMatrix","paths","Set","domains","undefined","matrix","push","getCookieValue","result","cookieArray","split","forEach","key","value","map","item","trim","decodeURIComponent","setCookie","days","expires","secureAttr","window","location","protocol","encodeURIComponent","deleteCookie"],"mappings":"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"}

package/dist/admin/admin/src/utils/cookies.mjs

@@ -7,8 +7,9 @@ import { resolveAuthCookiePath } from '../../../shared/utils/auth-cookie-path.mj
  * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_NAME`.
  */ const AUTH_COOKIE_NAME = resolveAuthCookieName(process.env.STRAPI_ADMIN_AUTH_COOKIE_NAME);
 /**
- * Resolved once at module load: the build inlines `admin.auth.cookie.path`
- * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_PATH`.
+ * Resolved once at module load: the build inlines `admin.auth.cookie.path`,
+ * or the path the panel is served from when it is unset, into the bundle as
+ * `STRAPI_ADMIN_AUTH_COOKIE_PATH`.
  */ const AUTH_COOKIE_PATH = resolveAuthCookiePath(process.env.STRAPI_ADMIN_AUTH_COOKIE_PATH);
 /**
  * Resolved once at module load: the build inlines `admin.auth.cookie.domain`
@@ -65,10 +66,10 @@ const expireCookieAt = (name, path, domain)=>{
 };
 /**
  * Sets a cookie with the given name, value, and optional expiration time.
- * Uses `admin.auth.cookie.path` and `admin.auth.cookie.domain` (both inlined
- * at build time) so the access cookie stays scoped to the same path and domain
- * as the httpOnly refresh cookie and the EE SSO access cookie. The cookie is
- * marked `Secure` whenever the page is served over TLS.
+ * Uses the access cookie path and `admin.auth.cookie.domain` (both inlined at
+ * build time) so the cookie lands on the same path and domain as the EE SSO
+ * access cookie written by the server. The cookie is marked `Secure` whenever
+ * the page is served over TLS.
  *
  * @param name - The name of the cookie.
  * @param value - The value of the cookie.

package/dist/admin/admin/src/utils/cookies.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cookies.mjs","sources":["../../../../../admin/src/utils/cookies.ts"],"sourcesContent":["import { resolveAuthCookieDomain } from '../../../shared/utils/auth-cookie-domain';\nimport { resolveAuthCookieName } from '../../../shared/utils/auth-cookie-name';\nimport { resolveAuthCookiePath } from '../../../shared/utils/auth-cookie-path';\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.name`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_NAME`.\n */\nexport const AUTH_COOKIE_NAME = resolveAuthCookieName(process.env.STRAPI_ADMIN_AUTH_COOKIE_NAME);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.path`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_PATH`.\n */\nexport const AUTH_COOKIE_PATH = resolveAuthCookiePath(process.env.STRAPI_ADMIN_AUTH_COOKIE_PATH);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.domain`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_DOMAIN`. `undefined` means the\n * cookie is host-only.\n */\nexport const AUTH_COOKIE_DOMAIN = resolveAuthCookieDomain(\n  process.env.STRAPI_ADMIN_AUTH_COOKIE_DOMAIN\n);\n\n/** Paths previously used by the client for the access cookie; cleared on set/delete. */\nconst LEGACY_AUTH_COOKIE_PATHS = ['/'] as const;\n\nconst expireCookieAt = (name: string, path: string, domain?: string): void => {\n  const domainAttr = domain ? `; Domain=${domain}` : '';\n  document.cookie = `${name}=; Path=${path}${domainAttr}; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;\n};\n\n/**\n * Every `(path, domain)` key the access cookie may live under: the configured\n * key plus the legacy-path and host-only variants written by older versions or\n * previous configs. The browser cookie store keys entries by\n * `(name, domain, path)`, so each combination is a distinct entry.\n */\nconst cookieKeyMatrix = (): Array<{ path: string; domain: string | undefined }> => {\n  const paths = new Set<string>([AUTH_COOKIE_PATH, ...LEGACY_AUTH_COOKIE_PATHS]);\n  const domains = new Set<string | undefined>([undefined, AUTH_COOKIE_DOMAIN]);\n\n  const matrix: Array<{ path: string; domain: string | undefined }> = [];\n  for (const path of paths) {\n    for (const domain of domains) {\n      matrix.push({ path, domain });\n    }\n  }\n  return matrix;\n};\n\n/**\n * Retrieves the value of a specified cookie.\n *\n * @param name - The name of the cookie to retrieve.\n * @returns The decoded cookie value if found, otherwise null.\n */\nexport const getCookieValue = (name: string): string | null => {\n  let result = null;\n  const cookieArray = document.cookie.split(';');\n  cookieArray.forEach((cookie) => {\n    const [key, value] = cookie.split('=').map((item) => item.trim());\n    if (key === name) {\n      result = decodeURIComponent(value);\n    }\n  });\n  return result;\n};\n\n/**\n * Sets a cookie with the given name, value, and optional expiration time.\n * Uses `admin.auth.cookie.path` and `admin.auth.cookie.domain` (both inlined\n * at build time) so the access cookie stays scoped to the same path and domain\n * as the httpOnly refresh cookie and the EE SSO access cookie. The cookie is\n * marked `Secure` whenever the page is served over TLS.\n *\n * @param name - The name of the cookie.\n * @param value - The value of the cookie.\n * @param days - (Optional) Number of days until the cookie expires. If omitted, the cookie is a session cookie.\n */\nexport const setCookie = (name: string, value: string, days?: number): void => {\n  let expires = '';\n  if (days) {\n    const date = new Date();\n    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);\n    expires = `; Expires=${date.toUTCString()}`;\n  }\n\n  // Expire every other key the cookie may live under (legacy Path=/, host-only\n  // copies written before a domain was configured). A stale same-name entry at\n  // an equal-length path sorts first in document.cookie by creation time\n  // (RFC 6265 §5.4), so leaving one behind would shadow the token written below.\n  for (const { path, domain } of cookieKeyMatrix()) {\n    if (path !== AUTH_COOKIE_PATH || domain !== AUTH_COOKIE_DOMAIN) {\n      expireCookieAt(name, path, domain);\n    }\n  }\n\n  const domainAttr = AUTH_COOKIE_DOMAIN ? `; Domain=${AUTH_COOKIE_DOMAIN}` : '';\n  // Mark the token Secure when the page itself is served over TLS — the\n  // browser's own criterion — so it is never attached to plain-http requests.\n  // Expiry writes stay flag-free on purpose: deletion targets the (name,\n  // domain, path) key regardless of Secure, and from an http origin a\n  // flag-free write can still clear non-Secure entries (no origin can carry\n  // the Secure flag over http, and Secure entries are untouchable from there\n  // either way).\n  const secureAttr = window.location.protocol === 'https:' ? '; Secure' : '';\n  document.cookie = `${name}=${encodeURIComponent(value)}; Path=${AUTH_COOKIE_PATH}${domainAttr}${expires}${secureAttr}`;\n};\n\n/**\n * Deletes a cookie by setting its expiration date to a past date.\n *\n * Expires every combination of {configured path, legacy Path=/} and\n * {configured domain, host-only}. A `Domain`-scoped cookie is a distinct entry\n * from a host-only one in the browser cookie store, so both must be cleared or\n * remote logout leaves the EE SSO cookie (written with `Domain` by the server)\n * behind, rehydrating a dead session into an infinite login redirect.\n *\n * @param name - The name of the cookie to delete.\n */\nexport const deleteCookie = (name: string): void => {\n  for (const { path, domain } of cookieKeyMatrix()) {\n    expireCookieAt(name, path, domain);\n  }\n};\n"],"names":["AUTH_COOKIE_NAME","resolveAuthCookieName","process","env","STRAPI_ADMIN_AUTH_COOKIE_NAME","AUTH_COOKIE_PATH","resolveAuthCookiePath","STRAPI_ADMIN_AUTH_COOKIE_PATH","AUTH_COOKIE_DOMAIN","resolveAuthCookieDomain","STRAPI_ADMIN_AUTH_COOKIE_DOMAIN","LEGACY_AUTH_COOKIE_PATHS","expireCookieAt","name","path","domain","domainAttr","document","cookie","cookieKeyMatrix","paths","Set","domains","undefined","matrix","push","getCookieValue","result","cookieArray","split","forEach","key","value","map","item","trim","decodeURIComponent","setCookie","days","expires","secureAttr","window","location","protocol","encodeURIComponent","deleteCookie"],"mappings":"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"}
+{"version":3,"file":"cookies.mjs","sources":["../../../../../admin/src/utils/cookies.ts"],"sourcesContent":["import { resolveAuthCookieDomain } from '../../../shared/utils/auth-cookie-domain';\nimport { resolveAuthCookieName } from '../../../shared/utils/auth-cookie-name';\nimport { resolveAuthCookiePath } from '../../../shared/utils/auth-cookie-path';\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.name`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_NAME`.\n */\nexport const AUTH_COOKIE_NAME = resolveAuthCookieName(process.env.STRAPI_ADMIN_AUTH_COOKIE_NAME);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.path`,\n * or the path the panel is served from when it is unset, into the bundle as\n * `STRAPI_ADMIN_AUTH_COOKIE_PATH`.\n */\nexport const AUTH_COOKIE_PATH = resolveAuthCookiePath(process.env.STRAPI_ADMIN_AUTH_COOKIE_PATH);\n\n/**\n * Resolved once at module load: the build inlines `admin.auth.cookie.domain`\n * into the bundle as `STRAPI_ADMIN_AUTH_COOKIE_DOMAIN`. `undefined` means the\n * cookie is host-only.\n */\nexport const AUTH_COOKIE_DOMAIN = resolveAuthCookieDomain(\n  process.env.STRAPI_ADMIN_AUTH_COOKIE_DOMAIN\n);\n\n/** Paths previously used by the client for the access cookie; cleared on set/delete. */\nconst LEGACY_AUTH_COOKIE_PATHS = ['/'] as const;\n\nconst expireCookieAt = (name: string, path: string, domain?: string): void => {\n  const domainAttr = domain ? `; Domain=${domain}` : '';\n  document.cookie = `${name}=; Path=${path}${domainAttr}; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;\n};\n\n/**\n * Every `(path, domain)` key the access cookie may live under: the configured\n * key plus the legacy-path and host-only variants written by older versions or\n * previous configs. The browser cookie store keys entries by\n * `(name, domain, path)`, so each combination is a distinct entry.\n */\nconst cookieKeyMatrix = (): Array<{ path: string; domain: string | undefined }> => {\n  const paths = new Set<string>([AUTH_COOKIE_PATH, ...LEGACY_AUTH_COOKIE_PATHS]);\n  const domains = new Set<string | undefined>([undefined, AUTH_COOKIE_DOMAIN]);\n\n  const matrix: Array<{ path: string; domain: string | undefined }> = [];\n  for (const path of paths) {\n    for (const domain of domains) {\n      matrix.push({ path, domain });\n    }\n  }\n  return matrix;\n};\n\n/**\n * Retrieves the value of a specified cookie.\n *\n * @param name - The name of the cookie to retrieve.\n * @returns The decoded cookie value if found, otherwise null.\n */\nexport const getCookieValue = (name: string): string | null => {\n  let result = null;\n  const cookieArray = document.cookie.split(';');\n  cookieArray.forEach((cookie) => {\n    const [key, value] = cookie.split('=').map((item) => item.trim());\n    if (key === name) {\n      result = decodeURIComponent(value);\n    }\n  });\n  return result;\n};\n\n/**\n * Sets a cookie with the given name, value, and optional expiration time.\n * Uses the access cookie path and `admin.auth.cookie.domain` (both inlined at\n * build time) so the cookie lands on the same path and domain as the EE SSO\n * access cookie written by the server. The cookie is marked `Secure` whenever\n * the page is served over TLS.\n *\n * @param name - The name of the cookie.\n * @param value - The value of the cookie.\n * @param days - (Optional) Number of days until the cookie expires. If omitted, the cookie is a session cookie.\n */\nexport const setCookie = (name: string, value: string, days?: number): void => {\n  let expires = '';\n  if (days) {\n    const date = new Date();\n    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);\n    expires = `; Expires=${date.toUTCString()}`;\n  }\n\n  // Expire every other key the cookie may live under (legacy Path=/, host-only\n  // copies written before a domain was configured). A stale same-name entry at\n  // an equal-length path sorts first in document.cookie by creation time\n  // (RFC 6265 §5.4), so leaving one behind would shadow the token written below.\n  for (const { path, domain } of cookieKeyMatrix()) {\n    if (path !== AUTH_COOKIE_PATH || domain !== AUTH_COOKIE_DOMAIN) {\n      expireCookieAt(name, path, domain);\n    }\n  }\n\n  const domainAttr = AUTH_COOKIE_DOMAIN ? `; Domain=${AUTH_COOKIE_DOMAIN}` : '';\n  // Mark the token Secure when the page itself is served over TLS — the\n  // browser's own criterion — so it is never attached to plain-http requests.\n  // Expiry writes stay flag-free on purpose: deletion targets the (name,\n  // domain, path) key regardless of Secure, and from an http origin a\n  // flag-free write can still clear non-Secure entries (no origin can carry\n  // the Secure flag over http, and Secure entries are untouchable from there\n  // either way).\n  const secureAttr = window.location.protocol === 'https:' ? '; Secure' : '';\n  document.cookie = `${name}=${encodeURIComponent(value)}; Path=${AUTH_COOKIE_PATH}${domainAttr}${expires}${secureAttr}`;\n};\n\n/**\n * Deletes a cookie by setting its expiration date to a past date.\n *\n * Expires every combination of {configured path, legacy Path=/} and\n * {configured domain, host-only}. A `Domain`-scoped cookie is a distinct entry\n * from a host-only one in the browser cookie store, so both must be cleared or\n * remote logout leaves the EE SSO cookie (written with `Domain` by the server)\n * behind, rehydrating a dead session into an infinite login redirect.\n *\n * @param name - The name of the cookie to delete.\n */\nexport const deleteCookie = (name: string): void => {\n  for (const { path, domain } of cookieKeyMatrix()) {\n    expireCookieAt(name, path, domain);\n  }\n};\n"],"names":["AUTH_COOKIE_NAME","resolveAuthCookieName","process","env","STRAPI_ADMIN_AUTH_COOKIE_NAME","AUTH_COOKIE_PATH","resolveAuthCookiePath","STRAPI_ADMIN_AUTH_COOKIE_PATH","AUTH_COOKIE_DOMAIN","resolveAuthCookieDomain","STRAPI_ADMIN_AUTH_COOKIE_DOMAIN","LEGACY_AUTH_COOKIE_PATHS","expireCookieAt","name","path","domain","domainAttr","document","cookie","cookieKeyMatrix","paths","Set","domains","undefined","matrix","push","getCookieValue","result","cookieArray","split","forEach","key","value","map","item","trim","decodeURIComponent","setCookie","days","expires","secureAttr","window","location","protocol","encodeURIComponent","deleteCookie"],"mappings":"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"}

package/dist/admin/admin/src/utils/getFetchClient.js

@@ -251,6 +251,29 @@ class FetchError extends Error {
 const isFetchError = (error)=>{
     return error instanceof FetchError;
 };
+/**
+ * Type guard that checks whether an error comes from an aborted operation,
+ * such as a `fetch` cancelled via `AbortController` or timed out via
+ * `AbortSignal.timeout()`.
+ *
+ * Note: if the controller was aborted with a custom reason
+ * (`controller.abort(reason)`), the operation rejects with that reason
+ * instead of an `AbortError`, and this guard returns `false`. In that case,
+ * also check the signal itself:
+ *
+ * @example
+ * try {
+ *   await fetch(url, { signal: controller.signal });
+ * } catch (err) {
+ *   if (isAbortError(err) || controller.signal.aborted) return;
+ *   throw err;
+ * }
+ *
+ * @param error - The caught value to check.
+ * @returns `true` if `error` is a `DOMException` named `AbortError` or `TimeoutError`.
+ */ function isAbortError(error) {
+    return error instanceof DOMException && (error.name === 'AbortError' || error.name === 'TimeoutError');
+}
 /**
  * @public
  * @param {FetchConfig} [defaultOptions={}] - Fetch Configs.
@@ -502,6 +525,7 @@ exports.ADMIN_REFRESH_LOCK = ADMIN_REFRESH_LOCK;
 exports.FetchError = FetchError;
 exports.attemptTokenRefresh = attemptTokenRefresh;
 exports.getFetchClient = getFetchClient;
+exports.isAbortError = isAbortError;
 exports.isFetchError = isFetchError;
 exports.refreshAccessToken = refreshAccessToken;
 exports.resetSessionExpiredNotification = resetSessionExpiredNotification;