@strapi/upload 5.52.0 → 5.52.1

package/dist/admin/future/components/TruncatedText.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var designSystem = require('@strapi/design-system');
+
+/**
+ * Text that ellipsizes, with a tooltip carrying the full value once it actually
+ * does. Used for folder and asset names, which are user-supplied and routinely
+ * longer than the column, card or rail holding them.
+ *
+ * The tooltip is conditional rather than always-on: a permanent tooltip would
+ * make every short name hoverable for no reason, and would announce a
+ * description that merely repeats the visible text.
+ *
+ * Whether the text is truncated can't be derived from the string — it depends on
+ * the rendered width — so it has to be measured. That measurement happens when
+ * the pointer or focus arrives, not at mount.
+ *
+ * Measuring at mount is the obvious approach and it does not work here. The
+ * reading is only correct once the row's width constraint has reached this span,
+ * and the tree remounts its rows during first render: the instance that survives
+ * can take its one measurement while still unconstrained, conclude it fits, and
+ * be stuck there. Nothing corrects it afterwards, because a ResizeObserver on
+ * this span never fires again — an ancestor clamps the row, so the text
+ * overflows inside a box whose own size stops changing.
+ *
+ * Reading on hover sidesteps all of that. It is the only moment the answer is
+ * needed, the layout is settled by then, and nothing is cached across remounts
+ * or resizes that could go stale.
+ */ const TruncatedText = ({ children, ...props })=>{
+    const textRef = React.useRef(null);
+    const [isTruncated, setIsTruncated] = React.useState(false);
+    const checkTruncation = ()=>{
+        const el = textRef.current;
+        if (el) {
+            setIsTruncated(el.scrollWidth > el.clientWidth);
+        }
+    };
+    // A ref callback rather than useRef alone, so the first measurement happens
+    // when the node attaches and again whenever it is replaced. The tree remounts
+    // its rows during first render, and a value measured against the discarded
+    // node would never be revisited — this re-runs against the node that survives.
+    const attachRef = (el)=>{
+        textRef.current = el;
+        if (el) {
+            checkTruncation();
+        }
+    };
+    // The Tooltip stays mounted and the *label* is what's conditional, rather than
+    // swapping between a wrapped and unwrapped span. Swapping loses the first
+    // hover: the measurement that decides to show a tooltip is itself triggered by
+    // the pointer arriving, so the trigger would mount underneath a pointer that
+    // has already entered, and Radix — which starts watching at mount — sees no
+    // enter event and stays closed until the pointer leaves and returns.
+    //
+    // With `label` empty the DS Tooltip renders its child as-is and attaches
+    // nothing, so untruncated text still costs no DOM node and announces no
+    // description duplicating what is already on screen.
+    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Tooltip, {
+        label: isTruncated ? children : undefined,
+        children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+            ref: attachRef,
+            ellipsis: true,
+            // Focus is covered as well as hover: the tooltip has to be reachable by
+            // keyboard, and these rows are buttons.
+            onPointerEnter: checkTruncation,
+            onFocus: checkTruncation,
+            ...props,
+            children: children
+        })
+    });
+};
+
+exports.TruncatedText = TruncatedText;
+//# sourceMappingURL=TruncatedText.js.map

package/dist/admin/future/components/TruncatedText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TruncatedText.js","sources":["../../../../admin/src/future/components/TruncatedText.tsx"],"sourcesContent":["import { useRef, useState } from 'react';\n\nimport { Tooltip, Typography, type TypographyProps } from '@strapi/design-system';\n\ninterface TruncatedTextProps extends Omit<TypographyProps, 'children' | 'ellipsis'> {\n  /** The full text. Doubles as the tooltip content once it no longer fits. */\n  children: string;\n}\n\n/**\n * Text that ellipsizes, with a tooltip carrying the full value once it actually\n * does. Used for folder and asset names, which are user-supplied and routinely\n * longer than the column, card or rail holding them.\n *\n * The tooltip is conditional rather than always-on: a permanent tooltip would\n * make every short name hoverable for no reason, and would announce a\n * description that merely repeats the visible text.\n *\n * Whether the text is truncated can't be derived from the string — it depends on\n * the rendered width — so it has to be measured. That measurement happens when\n * the pointer or focus arrives, not at mount.\n *\n * Measuring at mount is the obvious approach and it does not work here. The\n * reading is only correct once the row's width constraint has reached this span,\n * and the tree remounts its rows during first render: the instance that survives\n * can take its one measurement while still unconstrained, conclude it fits, and\n * be stuck there. Nothing corrects it afterwards, because a ResizeObserver on\n * this span never fires again — an ancestor clamps the row, so the text\n * overflows inside a box whose own size stops changing.\n *\n * Reading on hover sidesteps all of that. It is the only moment the answer is\n * needed, the layout is settled by then, and nothing is cached across remounts\n * or resizes that could go stale.\n */\nexport const TruncatedText = ({ children, ...props }: TruncatedTextProps) => {\n  const textRef = useRef<HTMLSpanElement | null>(null);\n  const [isTruncated, setIsTruncated] = useState(false);\n\n  const checkTruncation = () => {\n    const el = textRef.current;\n\n    if (el) {\n      setIsTruncated(el.scrollWidth > el.clientWidth);\n    }\n  };\n\n  // A ref callback rather than useRef alone, so the first measurement happens\n  // when the node attaches and again whenever it is replaced. The tree remounts\n  // its rows during first render, and a value measured against the discarded\n  // node would never be revisited — this re-runs against the node that survives.\n  const attachRef = (el: HTMLSpanElement | null) => {\n    textRef.current = el;\n\n    if (el) {\n      checkTruncation();\n    }\n  };\n\n  // The Tooltip stays mounted and the *label* is what's conditional, rather than\n  // swapping between a wrapped and unwrapped span. Swapping loses the first\n  // hover: the measurement that decides to show a tooltip is itself triggered by\n  // the pointer arriving, so the trigger would mount underneath a pointer that\n  // has already entered, and Radix — which starts watching at mount — sees no\n  // enter event and stays closed until the pointer leaves and returns.\n  //\n  // With `label` empty the DS Tooltip renders its child as-is and attaches\n  // nothing, so untruncated text still costs no DOM node and announces no\n  // description duplicating what is already on screen.\n  return (\n    <Tooltip label={isTruncated ? children : undefined}>\n      <Typography\n        ref={attachRef}\n        ellipsis\n        // Focus is covered as well as hover: the tooltip has to be reachable by\n        // keyboard, and these rows are buttons.\n        onPointerEnter={checkTruncation}\n        onFocus={checkTruncation}\n        {...props}\n      >\n        {children}\n      </Typography>\n    </Tooltip>\n  );\n};\n"],"names":["TruncatedText","children","props","textRef","useRef","isTruncated","setIsTruncated","useState","checkTruncation","el","current","scrollWidth","clientWidth","attachRef","_jsx","Tooltip","label","undefined","Typography","ref","ellipsis","onPointerEnter","onFocus"],"mappings":";;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;UAyBaA,aAAAA,GAAgB,CAAC,EAAEC,QAAQ,EAAE,GAAGC,KAAAA,EAA2B,GAAA;AACtE,IAAA,MAAMC,UAAUC,YAAAA,CAA+B,IAAA,CAAA;AAC/C,IAAA,MAAM,CAACC,WAAAA,EAAaC,cAAAA,CAAe,GAAGC,cAAAA,CAAS,KAAA,CAAA;AAE/C,IAAA,MAAMC,eAAAA,GAAkB,IAAA;QACtB,MAAMC,EAAAA,GAAKN,QAAQO,OAAO;AAE1B,QAAA,IAAID,EAAAA,EAAI;AACNH,YAAAA,cAAAA,CAAeG,EAAAA,CAAGE,WAAW,GAAGF,EAAAA,CAAGG,WAAW,CAAA;AAChD,QAAA;AACF,IAAA,CAAA;;;;;AAMA,IAAA,MAAMC,YAAY,CAACJ,EAAAA,GAAAA;AACjBN,QAAAA,OAAAA,CAAQO,OAAO,GAAGD,EAAAA;AAElB,QAAA,IAAIA,EAAAA,EAAI;AACND,YAAAA,eAAAA,EAAAA;AACF,QAAA;AACF,IAAA,CAAA;;;;;;;;;;;AAYA,IAAA,qBACEM,cAAA,CAACC,oBAAAA,EAAAA;AAAQC,QAAAA,KAAAA,EAAOX,cAAcJ,QAAAA,GAAWgB,SAAAA;AACvC,QAAA,QAAA,gBAAAH,cAAA,CAACI,uBAAAA,EAAAA;YACCC,GAAAA,EAAKN,SAAAA;YACLO,QAAQ,EAAA,IAAA;;;YAGRC,cAAAA,EAAgBb,eAAAA;YAChBc,OAAAA,EAASd,eAAAA;AACR,YAAA,GAAGN,KAAK;AAERD,YAAAA,QAAAA,EAAAA;;;AAIT;;;;"}

package/dist/admin/future/components/TruncatedText.mjs

@@ -0,0 +1,74 @@
+import { jsx } from 'react/jsx-runtime';
+import { useRef, useState } from 'react';
+import { Tooltip, Typography } from '@strapi/design-system';
+
+/**
+ * Text that ellipsizes, with a tooltip carrying the full value once it actually
+ * does. Used for folder and asset names, which are user-supplied and routinely
+ * longer than the column, card or rail holding them.
+ *
+ * The tooltip is conditional rather than always-on: a permanent tooltip would
+ * make every short name hoverable for no reason, and would announce a
+ * description that merely repeats the visible text.
+ *
+ * Whether the text is truncated can't be derived from the string — it depends on
+ * the rendered width — so it has to be measured. That measurement happens when
+ * the pointer or focus arrives, not at mount.
+ *
+ * Measuring at mount is the obvious approach and it does not work here. The
+ * reading is only correct once the row's width constraint has reached this span,
+ * and the tree remounts its rows during first render: the instance that survives
+ * can take its one measurement while still unconstrained, conclude it fits, and
+ * be stuck there. Nothing corrects it afterwards, because a ResizeObserver on
+ * this span never fires again — an ancestor clamps the row, so the text
+ * overflows inside a box whose own size stops changing.
+ *
+ * Reading on hover sidesteps all of that. It is the only moment the answer is
+ * needed, the layout is settled by then, and nothing is cached across remounts
+ * or resizes that could go stale.
+ */ const TruncatedText = ({ children, ...props })=>{
+    const textRef = useRef(null);
+    const [isTruncated, setIsTruncated] = useState(false);
+    const checkTruncation = ()=>{
+        const el = textRef.current;
+        if (el) {
+            setIsTruncated(el.scrollWidth > el.clientWidth);
+        }
+    };
+    // A ref callback rather than useRef alone, so the first measurement happens
+    // when the node attaches and again whenever it is replaced. The tree remounts
+    // its rows during first render, and a value measured against the discarded
+    // node would never be revisited — this re-runs against the node that survives.
+    const attachRef = (el)=>{
+        textRef.current = el;
+        if (el) {
+            checkTruncation();
+        }
+    };
+    // The Tooltip stays mounted and the *label* is what's conditional, rather than
+    // swapping between a wrapped and unwrapped span. Swapping loses the first
+    // hover: the measurement that decides to show a tooltip is itself triggered by
+    // the pointer arriving, so the trigger would mount underneath a pointer that
+    // has already entered, and Radix — which starts watching at mount — sees no
+    // enter event and stays closed until the pointer leaves and returns.
+    //
+    // With `label` empty the DS Tooltip renders its child as-is and attaches
+    // nothing, so untruncated text still costs no DOM node and announces no
+    // description duplicating what is already on screen.
+    return /*#__PURE__*/ jsx(Tooltip, {
+        label: isTruncated ? children : undefined,
+        children: /*#__PURE__*/ jsx(Typography, {
+            ref: attachRef,
+            ellipsis: true,
+            // Focus is covered as well as hover: the tooltip has to be reachable by
+            // keyboard, and these rows are buttons.
+            onPointerEnter: checkTruncation,
+            onFocus: checkTruncation,
+            ...props,
+            children: children
+        })
+    });
+};
+
+export { TruncatedText };
+//# sourceMappingURL=TruncatedText.mjs.map

package/dist/admin/future/components/TruncatedText.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TruncatedText.mjs","sources":["../../../../admin/src/future/components/TruncatedText.tsx"],"sourcesContent":["import { useRef, useState } from 'react';\n\nimport { Tooltip, Typography, type TypographyProps } from '@strapi/design-system';\n\ninterface TruncatedTextProps extends Omit<TypographyProps, 'children' | 'ellipsis'> {\n  /** The full text. Doubles as the tooltip content once it no longer fits. */\n  children: string;\n}\n\n/**\n * Text that ellipsizes, with a tooltip carrying the full value once it actually\n * does. Used for folder and asset names, which are user-supplied and routinely\n * longer than the column, card or rail holding them.\n *\n * The tooltip is conditional rather than always-on: a permanent tooltip would\n * make every short name hoverable for no reason, and would announce a\n * description that merely repeats the visible text.\n *\n * Whether the text is truncated can't be derived from the string — it depends on\n * the rendered width — so it has to be measured. That measurement happens when\n * the pointer or focus arrives, not at mount.\n *\n * Measuring at mount is the obvious approach and it does not work here. The\n * reading is only correct once the row's width constraint has reached this span,\n * and the tree remounts its rows during first render: the instance that survives\n * can take its one measurement while still unconstrained, conclude it fits, and\n * be stuck there. Nothing corrects it afterwards, because a ResizeObserver on\n * this span never fires again — an ancestor clamps the row, so the text\n * overflows inside a box whose own size stops changing.\n *\n * Reading on hover sidesteps all of that. It is the only moment the answer is\n * needed, the layout is settled by then, and nothing is cached across remounts\n * or resizes that could go stale.\n */\nexport const TruncatedText = ({ children, ...props }: TruncatedTextProps) => {\n  const textRef = useRef<HTMLSpanElement | null>(null);\n  const [isTruncated, setIsTruncated] = useState(false);\n\n  const checkTruncation = () => {\n    const el = textRef.current;\n\n    if (el) {\n      setIsTruncated(el.scrollWidth > el.clientWidth);\n    }\n  };\n\n  // A ref callback rather than useRef alone, so the first measurement happens\n  // when the node attaches and again whenever it is replaced. The tree remounts\n  // its rows during first render, and a value measured against the discarded\n  // node would never be revisited — this re-runs against the node that survives.\n  const attachRef = (el: HTMLSpanElement | null) => {\n    textRef.current = el;\n\n    if (el) {\n      checkTruncation();\n    }\n  };\n\n  // The Tooltip stays mounted and the *label* is what's conditional, rather than\n  // swapping between a wrapped and unwrapped span. Swapping loses the first\n  // hover: the measurement that decides to show a tooltip is itself triggered by\n  // the pointer arriving, so the trigger would mount underneath a pointer that\n  // has already entered, and Radix — which starts watching at mount — sees no\n  // enter event and stays closed until the pointer leaves and returns.\n  //\n  // With `label` empty the DS Tooltip renders its child as-is and attaches\n  // nothing, so untruncated text still costs no DOM node and announces no\n  // description duplicating what is already on screen.\n  return (\n    <Tooltip label={isTruncated ? children : undefined}>\n      <Typography\n        ref={attachRef}\n        ellipsis\n        // Focus is covered as well as hover: the tooltip has to be reachable by\n        // keyboard, and these rows are buttons.\n        onPointerEnter={checkTruncation}\n        onFocus={checkTruncation}\n        {...props}\n      >\n        {children}\n      </Typography>\n    </Tooltip>\n  );\n};\n"],"names":["TruncatedText","children","props","textRef","useRef","isTruncated","setIsTruncated","useState","checkTruncation","el","current","scrollWidth","clientWidth","attachRef","_jsx","Tooltip","label","undefined","Typography","ref","ellipsis","onPointerEnter","onFocus"],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;UAyBaA,aAAAA,GAAgB,CAAC,EAAEC,QAAQ,EAAE,GAAGC,KAAAA,EAA2B,GAAA;AACtE,IAAA,MAAMC,UAAUC,MAAAA,CAA+B,IAAA,CAAA;AAC/C,IAAA,MAAM,CAACC,WAAAA,EAAaC,cAAAA,CAAe,GAAGC,QAAAA,CAAS,KAAA,CAAA;AAE/C,IAAA,MAAMC,eAAAA,GAAkB,IAAA;QACtB,MAAMC,EAAAA,GAAKN,QAAQO,OAAO;AAE1B,QAAA,IAAID,EAAAA,EAAI;AACNH,YAAAA,cAAAA,CAAeG,EAAAA,CAAGE,WAAW,GAAGF,EAAAA,CAAGG,WAAW,CAAA;AAChD,QAAA;AACF,IAAA,CAAA;;;;;AAMA,IAAA,MAAMC,YAAY,CAACJ,EAAAA,GAAAA;AACjBN,QAAAA,OAAAA,CAAQO,OAAO,GAAGD,EAAAA;AAElB,QAAA,IAAIA,EAAAA,EAAI;AACND,YAAAA,eAAAA,EAAAA;AACF,QAAA;AACF,IAAA,CAAA;;;;;;;;;;;AAYA,IAAA,qBACEM,GAAA,CAACC,OAAAA,EAAAA;AAAQC,QAAAA,KAAAA,EAAOX,cAAcJ,QAAAA,GAAWgB,SAAAA;AACvC,QAAA,QAAA,gBAAAH,GAAA,CAACI,UAAAA,EAAAA;YACCC,GAAAA,EAAKN,SAAAA;YACLO,QAAQ,EAAA,IAAA;;;YAGRC,cAAAA,EAAgBb,eAAAA;YAChBc,OAAAA,EAASd,eAAAA;AACR,YAAA,GAAGN,KAAK;AAERD,YAAAA,QAAAA,EAAAA;;;AAIT;;;;"}

package/dist/admin/future/hooks/useTracking.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var React = require('react');
+var strapiAdmin = require('@strapi/admin/strapi-admin');
+var ee = require('@strapi/admin/strapi-admin/ee');
+var settings = require('../services/settings.js');
+
+/**
+ * Media Library version tag stamped on every event fired from the new
+ * (`src/future`) Media Library. Legacy events omit it, so analytics can filter
+ * new usage from the old plan while both trees emit the SAME event names (see
+ * CMS-246). Bump this if a future revamp ever needs its own bucket.
+ */ const MEDIA_LIBRARY_VERSION = 'v2';
+/**
+ * `location` value for every new Media Library event. The new tree is the
+ * standalone Media Library page, which the legacy plan tags `'upload'` (as
+ * opposed to `'content-manager'` for the asset-picker modal). Kept identical so
+ * migrated events line up with the legacy ones on the `location` axis.
+ */ const MEDIA_LIBRARY_LOCATION = 'upload';
+/**
+ * Tracking wrapper scoped to the new Media Library. Mirrors the legacy
+ * `admin/src/hooks/useTracking` — it forwards to the admin `trackUsage` and
+ * injects `isAiMediaLibraryConfigured` when AI is available — and additionally
+ * stamps `mediaLibraryVersion` on every event so the migrated plan stays
+ * distinguishable from the legacy one.
+ *
+ * The cast mirrors the legacy wrapper: these two properties are cross-cutting
+ * media-tracking metadata that the admin `TrackingEvent` type does not (and
+ * should not) enumerate per event.
+ */ const useTracking = ()=>{
+    const { trackUsage: trackStrapiUsage } = strapiAdmin.useTracking();
+    const { data } = settings.useGetUploadSettingsQuery();
+    const isAiAvailable = ee.useAIAvailability();
+    // Memoised so consumers can safely list `trackUsage` in effect deps (the
+    // search-input debounce commit does) without re-firing every render.
+    const trackUsage = React.useCallback((event, properties)=>{
+        return trackStrapiUsage(event, {
+            ...properties,
+            ...isAiAvailable ? {
+                isAiMediaLibraryConfigured: Boolean(data?.data?.aiMetadata)
+            } : {},
+            mediaLibraryVersion: MEDIA_LIBRARY_VERSION
+        });
+    }, [
+        trackStrapiUsage,
+        isAiAvailable,
+        data
+    ]);
+    return {
+        trackUsage
+    };
+};
+
+exports.MEDIA_LIBRARY_LOCATION = MEDIA_LIBRARY_LOCATION;
+exports.MEDIA_LIBRARY_VERSION = MEDIA_LIBRARY_VERSION;
+exports.useTracking = useTracking;
+//# sourceMappingURL=useTracking.js.map

package/dist/admin/future/hooks/useTracking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTracking.js","sources":["../../../../admin/src/future/hooks/useTracking.ts"],"sourcesContent":["import { useCallback } from 'react';\n\nimport { useTracking as useStrapiTracking, type TrackingEvent } from '@strapi/admin/strapi-admin';\nimport { useAIAvailability } from '@strapi/admin/strapi-admin/ee';\n\nimport { useGetUploadSettingsQuery } from '../services/settings';\n\n/**\n * Media Library version tag stamped on every event fired from the new\n * (`src/future`) Media Library. Legacy events omit it, so analytics can filter\n * new usage from the old plan while both trees emit the SAME event names (see\n * CMS-246). Bump this if a future revamp ever needs its own bucket.\n */\nexport const MEDIA_LIBRARY_VERSION = 'v2';\n\n/**\n * `location` value for every new Media Library event. The new tree is the\n * standalone Media Library page, which the legacy plan tags `'upload'` (as\n * opposed to `'content-manager'` for the asset-picker modal). Kept identical so\n * migrated events line up with the legacy ones on the `location` axis.\n */\nexport const MEDIA_LIBRARY_LOCATION = 'upload';\n\n/**\n * Tracking wrapper scoped to the new Media Library. Mirrors the legacy\n * `admin/src/hooks/useTracking` — it forwards to the admin `trackUsage` and\n * injects `isAiMediaLibraryConfigured` when AI is available — and additionally\n * stamps `mediaLibraryVersion` on every event so the migrated plan stays\n * distinguishable from the legacy one.\n *\n * The cast mirrors the legacy wrapper: these two properties are cross-cutting\n * media-tracking metadata that the admin `TrackingEvent` type does not (and\n * should not) enumerate per event.\n */\nexport const useTracking = () => {\n  const { trackUsage: trackStrapiUsage } = useStrapiTracking();\n  const { data } = useGetUploadSettingsQuery();\n  const isAiAvailable = useAIAvailability();\n\n  // Memoised so consumers can safely list `trackUsage` in effect deps (the\n  // search-input debounce commit does) without re-firing every render.\n  const trackUsage = useCallback(\n    <TEvent extends TrackingEvent>(event: TEvent['name'], properties?: TEvent['properties']) => {\n      return trackStrapiUsage(event, {\n        ...properties,\n        ...(isAiAvailable ? { isAiMediaLibraryConfigured: Boolean(data?.data?.aiMetadata) } : {}),\n        mediaLibraryVersion: MEDIA_LIBRARY_VERSION,\n      } as TEvent['properties']);\n    },\n    [trackStrapiUsage, isAiAvailable, data]\n  );\n\n  return { trackUsage };\n};\n"],"names":["MEDIA_LIBRARY_VERSION","MEDIA_LIBRARY_LOCATION","useTracking","trackUsage","trackStrapiUsage","useStrapiTracking","data","useGetUploadSettingsQuery","isAiAvailable","useAIAvailability","useCallback","event","properties","isAiMediaLibraryConfigured","Boolean","aiMetadata","mediaLibraryVersion"],"mappings":";;;;;;;AAOA;;;;;IAMO,MAAMA,qBAAAA,GAAwB;AAErC;;;;;IAMO,MAAMC,sBAAAA,GAAyB;AAEtC;;;;;;;;;;UAWaC,WAAAA,GAAc,IAAA;AACzB,IAAA,MAAM,EAAEC,UAAAA,EAAYC,gBAAgB,EAAE,GAAGC,uBAAAA,EAAAA;IACzC,MAAM,EAAEC,IAAI,EAAE,GAAGC,kCAAAA,EAAAA;AACjB,IAAA,MAAMC,aAAAA,GAAgBC,oBAAAA,EAAAA;;;IAItB,MAAMN,UAAAA,GAAaO,iBAAAA,CACjB,CAA+BC,KAAAA,EAAuBC,UAAAA,GAAAA;AACpD,QAAA,OAAOR,iBAAiBO,KAAAA,EAAO;AAC7B,YAAA,GAAGC,UAAU;AACb,YAAA,GAAIJ,aAAAA,GAAgB;gBAAEK,0BAAAA,EAA4BC,OAAAA,CAAQR,MAAMA,IAAAA,EAAMS,UAAAA;AAAY,aAAA,GAAI,EAAE;YACxFC,mBAAAA,EAAqBhB;AACvB,SAAA,CAAA;IACF,CAAA,EACA;AAACI,QAAAA,gBAAAA;AAAkBI,QAAAA,aAAAA;AAAeF,QAAAA;AAAK,KAAA,CAAA;IAGzC,OAAO;AAAEH,QAAAA;AAAW,KAAA;AACtB;;;;;;"}

package/dist/admin/future/hooks/useTracking.mjs

@@ -0,0 +1,53 @@
+import { useCallback } from 'react';
+import { useTracking as useTracking$1 } from '@strapi/admin/strapi-admin';
+import { useAIAvailability } from '@strapi/admin/strapi-admin/ee';
+import { useGetUploadSettingsQuery } from '../services/settings.mjs';
+
+/**
+ * Media Library version tag stamped on every event fired from the new
+ * (`src/future`) Media Library. Legacy events omit it, so analytics can filter
+ * new usage from the old plan while both trees emit the SAME event names (see
+ * CMS-246). Bump this if a future revamp ever needs its own bucket.
+ */ const MEDIA_LIBRARY_VERSION = 'v2';
+/**
+ * `location` value for every new Media Library event. The new tree is the
+ * standalone Media Library page, which the legacy plan tags `'upload'` (as
+ * opposed to `'content-manager'` for the asset-picker modal). Kept identical so
+ * migrated events line up with the legacy ones on the `location` axis.
+ */ const MEDIA_LIBRARY_LOCATION = 'upload';
+/**
+ * Tracking wrapper scoped to the new Media Library. Mirrors the legacy
+ * `admin/src/hooks/useTracking` — it forwards to the admin `trackUsage` and
+ * injects `isAiMediaLibraryConfigured` when AI is available — and additionally
+ * stamps `mediaLibraryVersion` on every event so the migrated plan stays
+ * distinguishable from the legacy one.
+ *
+ * The cast mirrors the legacy wrapper: these two properties are cross-cutting
+ * media-tracking metadata that the admin `TrackingEvent` type does not (and
+ * should not) enumerate per event.
+ */ const useTracking = ()=>{
+    const { trackUsage: trackStrapiUsage } = useTracking$1();
+    const { data } = useGetUploadSettingsQuery();
+    const isAiAvailable = useAIAvailability();
+    // Memoised so consumers can safely list `trackUsage` in effect deps (the
+    // search-input debounce commit does) without re-firing every render.
+    const trackUsage = useCallback((event, properties)=>{
+        return trackStrapiUsage(event, {
+            ...properties,
+            ...isAiAvailable ? {
+                isAiMediaLibraryConfigured: Boolean(data?.data?.aiMetadata)
+            } : {},
+            mediaLibraryVersion: MEDIA_LIBRARY_VERSION
+        });
+    }, [
+        trackStrapiUsage,
+        isAiAvailable,
+        data
+    ]);
+    return {
+        trackUsage
+    };
+};
+
+export { MEDIA_LIBRARY_LOCATION, MEDIA_LIBRARY_VERSION, useTracking };
+//# sourceMappingURL=useTracking.mjs.map

package/dist/admin/future/hooks/useTracking.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTracking.mjs","sources":["../../../../admin/src/future/hooks/useTracking.ts"],"sourcesContent":["import { useCallback } from 'react';\n\nimport { useTracking as useStrapiTracking, type TrackingEvent } from '@strapi/admin/strapi-admin';\nimport { useAIAvailability } from '@strapi/admin/strapi-admin/ee';\n\nimport { useGetUploadSettingsQuery } from '../services/settings';\n\n/**\n * Media Library version tag stamped on every event fired from the new\n * (`src/future`) Media Library. Legacy events omit it, so analytics can filter\n * new usage from the old plan while both trees emit the SAME event names (see\n * CMS-246). Bump this if a future revamp ever needs its own bucket.\n */\nexport const MEDIA_LIBRARY_VERSION = 'v2';\n\n/**\n * `location` value for every new Media Library event. The new tree is the\n * standalone Media Library page, which the legacy plan tags `'upload'` (as\n * opposed to `'content-manager'` for the asset-picker modal). Kept identical so\n * migrated events line up with the legacy ones on the `location` axis.\n */\nexport const MEDIA_LIBRARY_LOCATION = 'upload';\n\n/**\n * Tracking wrapper scoped to the new Media Library. Mirrors the legacy\n * `admin/src/hooks/useTracking` — it forwards to the admin `trackUsage` and\n * injects `isAiMediaLibraryConfigured` when AI is available — and additionally\n * stamps `mediaLibraryVersion` on every event so the migrated plan stays\n * distinguishable from the legacy one.\n *\n * The cast mirrors the legacy wrapper: these two properties are cross-cutting\n * media-tracking metadata that the admin `TrackingEvent` type does not (and\n * should not) enumerate per event.\n */\nexport const useTracking = () => {\n  const { trackUsage: trackStrapiUsage } = useStrapiTracking();\n  const { data } = useGetUploadSettingsQuery();\n  const isAiAvailable = useAIAvailability();\n\n  // Memoised so consumers can safely list `trackUsage` in effect deps (the\n  // search-input debounce commit does) without re-firing every render.\n  const trackUsage = useCallback(\n    <TEvent extends TrackingEvent>(event: TEvent['name'], properties?: TEvent['properties']) => {\n      return trackStrapiUsage(event, {\n        ...properties,\n        ...(isAiAvailable ? { isAiMediaLibraryConfigured: Boolean(data?.data?.aiMetadata) } : {}),\n        mediaLibraryVersion: MEDIA_LIBRARY_VERSION,\n      } as TEvent['properties']);\n    },\n    [trackStrapiUsage, isAiAvailable, data]\n  );\n\n  return { trackUsage };\n};\n"],"names":["MEDIA_LIBRARY_VERSION","MEDIA_LIBRARY_LOCATION","useTracking","trackUsage","trackStrapiUsage","useStrapiTracking","data","useGetUploadSettingsQuery","isAiAvailable","useAIAvailability","useCallback","event","properties","isAiMediaLibraryConfigured","Boolean","aiMetadata","mediaLibraryVersion"],"mappings":";;;;;AAOA;;;;;IAMO,MAAMA,qBAAAA,GAAwB;AAErC;;;;;IAMO,MAAMC,sBAAAA,GAAyB;AAEtC;;;;;;;;;;UAWaC,WAAAA,GAAc,IAAA;AACzB,IAAA,MAAM,EAAEC,UAAAA,EAAYC,gBAAgB,EAAE,GAAGC,aAAAA,EAAAA;IACzC,MAAM,EAAEC,IAAI,EAAE,GAAGC,yBAAAA,EAAAA;AACjB,IAAA,MAAMC,aAAAA,GAAgBC,iBAAAA,EAAAA;;;IAItB,MAAMN,UAAAA,GAAaO,WAAAA,CACjB,CAA+BC,KAAAA,EAAuBC,UAAAA,GAAAA;AACpD,QAAA,OAAOR,iBAAiBO,KAAAA,EAAO;AAC7B,YAAA,GAAGC,UAAU;AACb,YAAA,GAAIJ,aAAAA,GAAgB;gBAAEK,0BAAAA,EAA4BC,OAAAA,CAAQR,MAAMA,IAAAA,EAAMS,UAAAA;AAAY,aAAA,GAAI,EAAE;YACxFC,mBAAAA,EAAqBhB;AACvB,SAAA,CAAA;IACF,CAAA,EACA;AAACI,QAAAA,gBAAAA;AAAkBI,QAAAA,aAAAA;AAAeF,QAAAA;AAAK,KAAA,CAAA;IAGzC,OAAO;AAAEH,QAAAA;AAAW,KAAA;AACtB;;;;"}

package/dist/admin/future/pages/Assets/AssetsPage.js

@@ -8,9 +8,11 @@ var designSystem = require('@strapi/design-system');
 var icons = require('@strapi/icons');
 var reactIntl = require('react-intl');
 var styledComponents = require('styled-components');
+var typeFromMime = require('../../../utils/typeFromMime.js');
 var BetaNotice = require('../../components/BetaNotice.js');
 var useAIMetadataEnabled = require('../../hooks/useAIMetadataEnabled.js');
 var useMediaLibraryPermissions = require('../../hooks/useMediaLibraryPermissions.js');
+var useTracking = require('../../hooks/useTracking.js');
 var api = require('../../services/api.js');
 var folders = require('../../services/folders.js');
 var settings = require('../../services/settings.js');
@@ -488,8 +490,20 @@ const AssetsPage = ()=>{
     // dialog. No mime argument: the files are not known until they are picked,
     // and the server filters the batch on the same allowlist anyway.
     const isAiMetadataEnabled = useAIMetadataEnabled.useAIMetadataEnabled();
+    const { trackUsage } = useTracking.useTracking();
     const uploadFilesToFolder = async (files, folderId)=>{
         if (files.length === 0) return;
+        // Mirror the legacy `willAddMediaLibraryAssets` payload: the count of files
+        // about to upload, broken down by asset type.
+        const assetsCountByType = files.reduce((acc, file)=>{
+            const type = typeFromMime.typeFromMime(file.type);
+            acc[type] = (acc[type] ?? 0) + 1;
+            return acc;
+        }, {});
+        trackUsage('willAddMediaLibraryAssets', {
+            location: useTracking.MEDIA_LIBRARY_LOCATION,
+            ...assetsCountByType
+        });
         const formData = new FormData();
         const fileInfoArray = [];
         files.forEach((file)=>{
@@ -519,6 +533,10 @@ const AssetsPage = ()=>{
     const handleFileChange = async (e)=>{
         const files = e.target.files;
         if (files && files.length > 0) {
+            trackUsage('didSelectFile', {
+                source: 'computer',
+                location: useTracking.MEDIA_LIBRARY_LOCATION
+            });
             await uploadFilesToFolder(Array.from(files), currentFolderId);
         }
         e.target.value = '';
@@ -527,9 +545,22 @@ const AssetsPage = ()=>{
         // Defence in depth: the provider is `disabled` without `assets.create`
         // (so onDrop won't fire), but guard here too in case it's ever wired live.
         if (!canCreate) return;
+        trackUsage('didSelectFile', {
+            source: 'computer',
+            location: useTracking.MEDIA_LIBRARY_LOCATION
+        });
         await uploadFilesToFolder(files, currentFolderId);
     };
     const handleUrlUpload = async (urls)=>{
+        trackUsage('didSelectFile', {
+            source: 'url',
+            location: useTracking.MEDIA_LIBRARY_LOCATION
+        });
+        // Counts-by-type aren't available client-side for the URL flow (the server
+        // fetches the files), so this fires the event with location only.
+        trackUsage('willAddMediaLibraryAssets', {
+            location: useTracking.MEDIA_LIBRARY_LOCATION
+        });
         try {
             await uploadFromUrls({
                 urls,