@strapi/upload 5.52.2 → 5.53.0

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

@@ -74,7 +74,8 @@ var en = {
     "upload.progress.success": "Upload successful!",
     "upload.progress.success.subtitle": "{count, plural, one {# file uploaded successfully} other {# files uploaded successfully}}",
     "upload.progress.success.subtitle.withErrors": "{successCount} uploaded, {errorCount} failed",
-    "upload.progress.uploading.withCount": "Uploading {total} items ({percentage}%)",
+    "upload.progress.uploading.withCount": "Uploading {total, plural, one {# item} other {# items}} ({percentage}%)",
+    "upload.progress.uploading.indeterminate": "Uploading {total, plural, one {# item} other {# items}}",
     "upload.progress.uploading-files": "Uploading {count, plural, one {# file} other {# files}}",
     "upload.progress.indicator.in-progress": "Upload in progress indicator",
     "upload.progress.indicator.complete": "Upload complete indicator",
@@ -338,8 +339,10 @@ var en = {
     "list.table.row.select": "Select {name}",
     "list.table.row.metadata-missing": "This asset is missing metadata (caption or alternative text).",
     "list.table.content.empty-label": "This field is empty",
+    "list.context-menu.label": "Media library actions",
     "list.bulk-actions.label": "Bulk actions",
     "list.bulk-actions.selected-count": "{count, plural, =1 {# item selected} other {# items selected}}",
+    "list.bulk-actions.select-all": "Select all",
     "list.bulk-actions.clear": "Clear selection",
     "list.bulk-actions.create-metadata": "Create metadata",
     "list.bulk-actions.create-metadata.success": "{count, plural, =1 {Metadata generated for # asset} other {Metadata generated for # assets}}",
@@ -385,6 +388,7 @@ var en = {
     "sidebar.folders": "Folders",
     "sidebar.tree.aria-label": "Media library folders",
     "sidebar.tree.expand": "Expand {name}",
+    "sidebar.tree.no-subfolders": "The folder {name} has no subfolders",
     "sidebar.tree.collapse": "Collapse {name}",
     "sidebar.tree.empty": "No folders yet",
     "sidebar.tree.loading": "Loading folders...",

package/dist/admin/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/utils/getFolderURL.js

@@ -1,11 +1,12 @@
 'use strict';
 
+var strapiAdmin = require('@strapi/admin/strapi-admin');
 var qs = require('qs');
 
 const getFolderURL = (pathname, currentQuery, { folder, folderPath } = {})=>{
     const { _q, ...queryParamsWithoutQ } = currentQuery;
     const queryParamsString = qs.stringify({
-        ...queryParamsWithoutQ,
+        ...strapiAdmin.deepEncodeQueryValues(queryParamsWithoutQ),
         folder,
         folderPath
     }, {

package/dist/admin/utils/getFolderURL.js.map

@@ -1 +1 @@
-{"version":3,"file":"getFolderURL.js","sources":["../../../admin/src/utils/getFolderURL.ts"],"sourcesContent":["import { stringify } from 'qs';\n\nimport type { Query } from '../../../shared/contracts/files';\n\nexport const getFolderURL = (\n  pathname: string,\n  currentQuery: Query,\n  { folder, folderPath }: { folder?: string; folderPath?: string } = {}\n) => {\n  const { _q, ...queryParamsWithoutQ } = currentQuery;\n  const queryParamsString = stringify(\n    {\n      ...queryParamsWithoutQ,\n      folder,\n      folderPath,\n    },\n    { encode: false }\n  );\n\n  // Search query will always fetch the same results\n  // we remove it here to allow navigating in a folder and see the result of this navigation\n  return `${pathname}${queryParamsString ? `?${queryParamsString}` : ''}`;\n};\n"],"names":["getFolderURL","pathname","currentQuery","folder","folderPath","_q","queryParamsWithoutQ","queryParamsString","stringify","encode"],"mappings":";;;;AAIO,MAAMA,YAAAA,GAAe,CAC1BC,QAAAA,EACAC,YAAAA,EACA,EAAEC,MAAM,EAAEC,UAAU,EAA4C,GAAG,EAAE,GAAA;AAErE,IAAA,MAAM,EAAEC,EAAE,EAAE,GAAGC,qBAAqB,GAAGJ,YAAAA;AACvC,IAAA,MAAMK,oBAAoBC,YAAAA,CACxB;AACE,QAAA,GAAGF,mBAAmB;AACtBH,QAAAA,MAAAA;AACAC,QAAAA;KACF,EACA;QAAEK,MAAAA,EAAQ;AAAM,KAAA,CAAA;;;IAKlB,OAAO,CAAA,EAAGR,WAAWM,iBAAAA,GAAoB,CAAC,CAAC,EAAEA,iBAAAA,CAAAA,CAAmB,GAAG,EAAA,CAAA,CAAI;AACzE;;;;"}
+{"version":3,"file":"getFolderURL.js","sources":["../../../admin/src/utils/getFolderURL.ts"],"sourcesContent":["import { deepEncodeQueryValues } from '@strapi/admin/strapi-admin';\nimport { stringify } from 'qs';\n\nimport type { Query } from '../../../shared/contracts/files';\n\nexport const getFolderURL = (\n  pathname: string,\n  currentQuery: Query,\n  { folder, folderPath }: { folder?: string; folderPath?: string } = {}\n) => {\n  const { _q, ...queryParamsWithoutQ } = currentQuery;\n  const queryParamsString = stringify(\n    {\n      ...deepEncodeQueryValues(queryParamsWithoutQ),\n      folder,\n      folderPath,\n    },\n    { encode: false }\n  );\n\n  // Search query will always fetch the same results\n  // we remove it here to allow navigating in a folder and see the result of this navigation\n  return `${pathname}${queryParamsString ? `?${queryParamsString}` : ''}`;\n};\n"],"names":["getFolderURL","pathname","currentQuery","folder","folderPath","_q","queryParamsWithoutQ","queryParamsString","stringify","deepEncodeQueryValues","encode"],"mappings":";;;;;AAKO,MAAMA,YAAAA,GAAe,CAC1BC,QAAAA,EACAC,YAAAA,EACA,EAAEC,MAAM,EAAEC,UAAU,EAA4C,GAAG,EAAE,GAAA;AAErE,IAAA,MAAM,EAAEC,EAAE,EAAE,GAAGC,qBAAqB,GAAGJ,YAAAA;AACvC,IAAA,MAAMK,oBAAoBC,YAAAA,CACxB;AACE,QAAA,GAAGC,kCAAsBH,mBAAAA,CAAoB;AAC7CH,QAAAA,MAAAA;AACAC,QAAAA;KACF,EACA;QAAEM,MAAAA,EAAQ;AAAM,KAAA,CAAA;;;IAKlB,OAAO,CAAA,EAAGT,WAAWM,iBAAAA,GAAoB,CAAC,CAAC,EAAEA,iBAAAA,CAAAA,CAAmB,GAAG,EAAA,CAAA,CAAI;AACzE;;;;"}

package/dist/admin/utils/getFolderURL.mjs

@@ -1,9 +1,10 @@
+import { deepEncodeQueryValues } from '@strapi/admin/strapi-admin';
 import { stringify } from 'qs';
 
 const getFolderURL = (pathname, currentQuery, { folder, folderPath } = {})=>{
     const { _q, ...queryParamsWithoutQ } = currentQuery;
     const queryParamsString = stringify({
-        ...queryParamsWithoutQ,
+        ...deepEncodeQueryValues(queryParamsWithoutQ),
         folder,
         folderPath
     }, {

package/dist/admin/utils/getFolderURL.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getFolderURL.mjs","sources":["../../../admin/src/utils/getFolderURL.ts"],"sourcesContent":["import { stringify } from 'qs';\n\nimport type { Query } from '../../../shared/contracts/files';\n\nexport const getFolderURL = (\n  pathname: string,\n  currentQuery: Query,\n  { folder, folderPath }: { folder?: string; folderPath?: string } = {}\n) => {\n  const { _q, ...queryParamsWithoutQ } = currentQuery;\n  const queryParamsString = stringify(\n    {\n      ...queryParamsWithoutQ,\n      folder,\n      folderPath,\n    },\n    { encode: false }\n  );\n\n  // Search query will always fetch the same results\n  // we remove it here to allow navigating in a folder and see the result of this navigation\n  return `${pathname}${queryParamsString ? `?${queryParamsString}` : ''}`;\n};\n"],"names":["getFolderURL","pathname","currentQuery","folder","folderPath","_q","queryParamsWithoutQ","queryParamsString","stringify","encode"],"mappings":";;AAIO,MAAMA,YAAAA,GAAe,CAC1BC,QAAAA,EACAC,YAAAA,EACA,EAAEC,MAAM,EAAEC,UAAU,EAA4C,GAAG,EAAE,GAAA;AAErE,IAAA,MAAM,EAAEC,EAAE,EAAE,GAAGC,qBAAqB,GAAGJ,YAAAA;AACvC,IAAA,MAAMK,oBAAoBC,SAAAA,CACxB;AACE,QAAA,GAAGF,mBAAmB;AACtBH,QAAAA,MAAAA;AACAC,QAAAA;KACF,EACA;QAAEK,MAAAA,EAAQ;AAAM,KAAA,CAAA;;;IAKlB,OAAO,CAAA,EAAGR,WAAWM,iBAAAA,GAAoB,CAAC,CAAC,EAAEA,iBAAAA,CAAAA,CAAmB,GAAG,EAAA,CAAA,CAAI;AACzE;;;;"}
+{"version":3,"file":"getFolderURL.mjs","sources":["../../../admin/src/utils/getFolderURL.ts"],"sourcesContent":["import { deepEncodeQueryValues } from '@strapi/admin/strapi-admin';\nimport { stringify } from 'qs';\n\nimport type { Query } from '../../../shared/contracts/files';\n\nexport const getFolderURL = (\n  pathname: string,\n  currentQuery: Query,\n  { folder, folderPath }: { folder?: string; folderPath?: string } = {}\n) => {\n  const { _q, ...queryParamsWithoutQ } = currentQuery;\n  const queryParamsString = stringify(\n    {\n      ...deepEncodeQueryValues(queryParamsWithoutQ),\n      folder,\n      folderPath,\n    },\n    { encode: false }\n  );\n\n  // Search query will always fetch the same results\n  // we remove it here to allow navigating in a folder and see the result of this navigation\n  return `${pathname}${queryParamsString ? `?${queryParamsString}` : ''}`;\n};\n"],"names":["getFolderURL","pathname","currentQuery","folder","folderPath","_q","queryParamsWithoutQ","queryParamsString","stringify","deepEncodeQueryValues","encode"],"mappings":";;;AAKO,MAAMA,YAAAA,GAAe,CAC1BC,QAAAA,EACAC,YAAAA,EACA,EAAEC,MAAM,EAAEC,UAAU,EAA4C,GAAG,EAAE,GAAA;AAErE,IAAA,MAAM,EAAEC,EAAE,EAAE,GAAGC,qBAAqB,GAAGJ,YAAAA;AACvC,IAAA,MAAMK,oBAAoBC,SAAAA,CACxB;AACE,QAAA,GAAGC,sBAAsBH,mBAAAA,CAAoB;AAC7CH,QAAAA,MAAAA;AACAC,QAAAA;KACF,EACA;QAAEM,MAAAA,EAAQ;AAAM,KAAA,CAAA;;;IAKlB,OAAO,CAAA,EAAGT,WAAWM,iBAAAA,GAAoB,CAAC,CAAC,EAAEA,iBAAAA,CAAAA,CAAmB,GAAG,EAAA,CAAA,CAAI;AACzE;;;;"}

package/dist/admin/utils/rawFileToAsset.js

@@ -1,17 +1,19 @@
 'use strict';
 
+var resolveFileMime = require('./resolveFileMime.js');
 var typeFromMime = require('./typeFromMime.js');
 
-const rawFileToAsset = (rawFile, assetSource)=>{
+const rawFileToAsset = async (rawFile, assetSource)=>{
+    const mime = await resolveFileMime.resolveFileMime(rawFile.type, rawFile);
     return {
         size: rawFile.size / 1000,
         createdAt: new Date(rawFile.lastModified).toISOString(),
         name: rawFile.name,
         source: assetSource,
-        type: typeFromMime.typeFromMime(rawFile.type),
+        type: typeFromMime.typeFromMime(mime),
         url: URL.createObjectURL(rawFile),
         ext: rawFile.name.split('.').pop(),
-        mime: rawFile.type,
+        mime,
         rawFile,
         isLocal: true
     };

package/dist/admin/utils/rawFileToAsset.js.map

@@ -1 +1 @@
-{"version":3,"file":"rawFileToAsset.js","sources":["../../../admin/src/utils/rawFileToAsset.ts"],"sourcesContent":["import { AssetSource } from '../constants';\n\nimport { typeFromMime } from './typeFromMime';\n\nimport type { RawFile } from '../../../shared/contracts/files';\n\nexport const rawFileToAsset = (rawFile: RawFile, assetSource: AssetSource) => {\n  return {\n    size: rawFile.size / 1000,\n    createdAt: new Date(rawFile.lastModified).toISOString(),\n    name: rawFile.name,\n    source: assetSource,\n    type: typeFromMime(rawFile.type),\n    url: URL.createObjectURL(rawFile),\n    ext: rawFile.name.split('.').pop(),\n    mime: rawFile.type,\n    rawFile,\n    isLocal: true,\n  };\n};\n"],"names":["rawFileToAsset","rawFile","assetSource","size","createdAt","Date","lastModified","toISOString","name","source","type","typeFromMime","url","URL","createObjectURL","ext","split","pop","mime","isLocal"],"mappings":";;;;AAMO,MAAMA,cAAAA,GAAiB,CAACC,OAAAA,EAAkBC,WAAAA,GAAAA;IAC/C,OAAO;QACLC,IAAAA,EAAMF,OAAAA,CAAQE,IAAI,GAAG,IAAA;AACrBC,QAAAA,SAAAA,EAAW,IAAIC,IAAAA,CAAKJ,OAAAA,CAAQK,YAAY,EAAEC,WAAW,EAAA;AACrDC,QAAAA,IAAAA,EAAMP,QAAQO,IAAI;QAClBC,MAAAA,EAAQP,WAAAA;QACRQ,IAAAA,EAAMC,yBAAAA,CAAaV,QAAQS,IAAI,CAAA;QAC/BE,GAAAA,EAAKC,GAAAA,CAAIC,eAAe,CAACb,OAAAA,CAAAA;AACzBc,QAAAA,GAAAA,EAAKd,QAAQO,IAAI,CAACQ,KAAK,CAAC,KAAKC,GAAG,EAAA;AAChCC,QAAAA,IAAAA,EAAMjB,QAAQS,IAAI;AAClBT,QAAAA,OAAAA;QACAkB,OAAAA,EAAS;AACX,KAAA;AACF;;;;"}
+{"version":3,"file":"rawFileToAsset.js","sources":["../../../admin/src/utils/rawFileToAsset.ts"],"sourcesContent":["import { AssetSource } from '../constants';\n\nimport { resolveFileMime } from './resolveFileMime';\nimport { typeFromMime } from './typeFromMime';\n\nimport type { RawFile } from '../../../shared/contracts/files';\n\nexport const rawFileToAsset = async (rawFile: RawFile, assetSource: AssetSource) => {\n  const mime = await resolveFileMime(rawFile.type, rawFile);\n\n  return {\n    size: rawFile.size / 1000,\n    createdAt: new Date(rawFile.lastModified).toISOString(),\n    name: rawFile.name,\n    source: assetSource,\n    type: typeFromMime(mime),\n    url: URL.createObjectURL(rawFile),\n    ext: rawFile.name.split('.').pop(),\n    mime,\n    rawFile,\n    isLocal: true,\n  };\n};\n"],"names":["rawFileToAsset","rawFile","assetSource","mime","resolveFileMime","type","size","createdAt","Date","lastModified","toISOString","name","source","typeFromMime","url","URL","createObjectURL","ext","split","pop","isLocal"],"mappings":";;;;;AAOO,MAAMA,cAAAA,GAAiB,OAAOC,OAAAA,EAAkBC,WAAAA,GAAAA;AACrD,IAAA,MAAMC,IAAAA,GAAO,MAAMC,+BAAAA,CAAgBH,OAAAA,CAAQI,IAAI,EAAEJ,OAAAA,CAAAA;IAEjD,OAAO;QACLK,IAAAA,EAAML,OAAAA,CAAQK,IAAI,GAAG,IAAA;AACrBC,QAAAA,SAAAA,EAAW,IAAIC,IAAAA,CAAKP,OAAAA,CAAQQ,YAAY,EAAEC,WAAW,EAAA;AACrDC,QAAAA,IAAAA,EAAMV,QAAQU,IAAI;QAClBC,MAAAA,EAAQV,WAAAA;AACRG,QAAAA,IAAAA,EAAMQ,yBAAAA,CAAaV,IAAAA,CAAAA;QACnBW,GAAAA,EAAKC,GAAAA,CAAIC,eAAe,CAACf,OAAAA,CAAAA;AACzBgB,QAAAA,GAAAA,EAAKhB,QAAQU,IAAI,CAACO,KAAK,CAAC,KAAKC,GAAG,EAAA;AAChChB,QAAAA,IAAAA;AACAF,QAAAA,OAAAA;QACAmB,OAAAA,EAAS;AACX,KAAA;AACF;;;;"}

package/dist/admin/utils/rawFileToAsset.mjs

@@ -1,15 +1,17 @@
+import { resolveFileMime } from './resolveFileMime.mjs';
 import { typeFromMime } from './typeFromMime.mjs';
 
-const rawFileToAsset = (rawFile, assetSource)=>{
+const rawFileToAsset = async (rawFile, assetSource)=>{
+    const mime = await resolveFileMime(rawFile.type, rawFile);
     return {
         size: rawFile.size / 1000,
         createdAt: new Date(rawFile.lastModified).toISOString(),
         name: rawFile.name,
         source: assetSource,
-        type: typeFromMime(rawFile.type),
+        type: typeFromMime(mime),
         url: URL.createObjectURL(rawFile),
         ext: rawFile.name.split('.').pop(),
-        mime: rawFile.type,
+        mime,
         rawFile,
         isLocal: true
     };

package/dist/admin/utils/rawFileToAsset.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rawFileToAsset.mjs","sources":["../../../admin/src/utils/rawFileToAsset.ts"],"sourcesContent":["import { AssetSource } from '../constants';\n\nimport { typeFromMime } from './typeFromMime';\n\nimport type { RawFile } from '../../../shared/contracts/files';\n\nexport const rawFileToAsset = (rawFile: RawFile, assetSource: AssetSource) => {\n  return {\n    size: rawFile.size / 1000,\n    createdAt: new Date(rawFile.lastModified).toISOString(),\n    name: rawFile.name,\n    source: assetSource,\n    type: typeFromMime(rawFile.type),\n    url: URL.createObjectURL(rawFile),\n    ext: rawFile.name.split('.').pop(),\n    mime: rawFile.type,\n    rawFile,\n    isLocal: true,\n  };\n};\n"],"names":["rawFileToAsset","rawFile","assetSource","size","createdAt","Date","lastModified","toISOString","name","source","type","typeFromMime","url","URL","createObjectURL","ext","split","pop","mime","isLocal"],"mappings":";;AAMO,MAAMA,cAAAA,GAAiB,CAACC,OAAAA,EAAkBC,WAAAA,GAAAA;IAC/C,OAAO;QACLC,IAAAA,EAAMF,OAAAA,CAAQE,IAAI,GAAG,IAAA;AACrBC,QAAAA,SAAAA,EAAW,IAAIC,IAAAA,CAAKJ,OAAAA,CAAQK,YAAY,EAAEC,WAAW,EAAA;AACrDC,QAAAA,IAAAA,EAAMP,QAAQO,IAAI;QAClBC,MAAAA,EAAQP,WAAAA;QACRQ,IAAAA,EAAMC,YAAAA,CAAaV,QAAQS,IAAI,CAAA;QAC/BE,GAAAA,EAAKC,GAAAA,CAAIC,eAAe,CAACb,OAAAA,CAAAA;AACzBc,QAAAA,GAAAA,EAAKd,QAAQO,IAAI,CAACQ,KAAK,CAAC,KAAKC,GAAG,EAAA;AAChCC,QAAAA,IAAAA,EAAMjB,QAAQS,IAAI;AAClBT,QAAAA,OAAAA;QACAkB,OAAAA,EAAS;AACX,KAAA;AACF;;;;"}
+{"version":3,"file":"rawFileToAsset.mjs","sources":["../../../admin/src/utils/rawFileToAsset.ts"],"sourcesContent":["import { AssetSource } from '../constants';\n\nimport { resolveFileMime } from './resolveFileMime';\nimport { typeFromMime } from './typeFromMime';\n\nimport type { RawFile } from '../../../shared/contracts/files';\n\nexport const rawFileToAsset = async (rawFile: RawFile, assetSource: AssetSource) => {\n  const mime = await resolveFileMime(rawFile.type, rawFile);\n\n  return {\n    size: rawFile.size / 1000,\n    createdAt: new Date(rawFile.lastModified).toISOString(),\n    name: rawFile.name,\n    source: assetSource,\n    type: typeFromMime(mime),\n    url: URL.createObjectURL(rawFile),\n    ext: rawFile.name.split('.').pop(),\n    mime,\n    rawFile,\n    isLocal: true,\n  };\n};\n"],"names":["rawFileToAsset","rawFile","assetSource","mime","resolveFileMime","type","size","createdAt","Date","lastModified","toISOString","name","source","typeFromMime","url","URL","createObjectURL","ext","split","pop","isLocal"],"mappings":";;;AAOO,MAAMA,cAAAA,GAAiB,OAAOC,OAAAA,EAAkBC,WAAAA,GAAAA;AACrD,IAAA,MAAMC,IAAAA,GAAO,MAAMC,eAAAA,CAAgBH,OAAAA,CAAQI,IAAI,EAAEJ,OAAAA,CAAAA;IAEjD,OAAO;QACLK,IAAAA,EAAML,OAAAA,CAAQK,IAAI,GAAG,IAAA;AACrBC,QAAAA,SAAAA,EAAW,IAAIC,IAAAA,CAAKP,OAAAA,CAAQQ,YAAY,EAAEC,WAAW,EAAA;AACrDC,QAAAA,IAAAA,EAAMV,QAAQU,IAAI;QAClBC,MAAAA,EAAQV,WAAAA;AACRG,QAAAA,IAAAA,EAAMQ,YAAAA,CAAaV,IAAAA,CAAAA;QACnBW,GAAAA,EAAKC,GAAAA,CAAIC,eAAe,CAACf,OAAAA,CAAAA;AACzBgB,QAAAA,GAAAA,EAAKhB,QAAQU,IAAI,CAACO,KAAK,CAAC,KAAKC,GAAG,EAAA;AAChChB,QAAAA,IAAAA;AACAF,QAAAA,OAAAA;QACAmB,OAAAA,EAAS;AACX,KAAA;AACF;;;;"}

package/dist/admin/utils/resolveFileMime.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const GENERIC_MIMES = new Set([
+    '',
+    'application/octet-stream'
+]);
+/**
+ * Same byte window currently used by server MIME validation (`readFileChunk(..., 4100)`).
+ * Magic-number detection only needs the start of the file.
+ */ const FILE_TYPE_SNIFF_BYTES = 4100;
+const normalizeDeclaredMime = (mime)=>(mime ?? '').trim().split(';')[0].trim();
+const isGenericMime = (mime)=>{
+    const declared = normalizeDeclaredMime(mime);
+    return !declared || GENERIC_MIMES.has(declared.toLowerCase());
+};
+const readBlobBytes = async (blob)=>{
+    const chunk = typeof blob.slice === 'function' ? blob.slice(0, FILE_TYPE_SNIFF_BYTES) : blob;
+    if (typeof chunk.arrayBuffer === 'function') {
+        return new Uint8Array(await chunk.arrayBuffer());
+    }
+    // jsdom's Blob.slice() result has no arrayBuffer(); FileReader works in browsers and tests.
+    return new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onload = ()=>{
+            resolve(new Uint8Array(reader.result));
+        };
+        reader.onerror = ()=>{
+            reject(reader.error ?? new Error('Failed to read file'));
+        };
+        reader.readAsArrayBuffer(chunk);
+    });
+};
+/**
+ * Detect MIME from file bytes with file-type.
+ * The admin normalizes declared MIME values more permissively; server validation remains authoritative.
+ * Returns undefined when the blob cannot be read or the type is unknown.
+ */ const detectMimeFromBlob = async (blob)=>{
+    try {
+        const buffer = await readBlobBytes(blob);
+        // Browser/core build — do not pull the Node `file-type` entry into the admin bundle.
+        const { fileTypeFromBuffer } = await import('file-type/core');
+        const result = await fileTypeFromBuffer(buffer);
+        return result?.mime;
+    } catch  {
+        return undefined;
+    }
+};
+/**
+ * When the browser MIME is missing or generic, sniff the file contents.
+ * If there is no blob (library assets) or detection fails, keep the declared type.
+ */ const resolveFileMime = async (mime, blob)=>{
+    const declared = normalizeDeclaredMime(mime);
+    if (declared && !isGenericMime(declared)) {
+        return declared;
+    }
+    if (blob) {
+        const detected = await detectMimeFromBlob(blob);
+        if (detected) {
+            return detected;
+        }
+    }
+    return declared;
+};
+
+exports.detectMimeFromBlob = detectMimeFromBlob;
+exports.isGenericMime = isGenericMime;
+exports.normalizeDeclaredMime = normalizeDeclaredMime;
+exports.resolveFileMime = resolveFileMime;
+//# sourceMappingURL=resolveFileMime.js.map

package/dist/admin/utils/resolveFileMime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveFileMime.js","sources":["../../../admin/src/utils/resolveFileMime.ts"],"sourcesContent":["const GENERIC_MIMES = new Set(['', 'application/octet-stream']);\n\n/**\n * Same byte window currently used by server MIME validation (`readFileChunk(..., 4100)`).\n * Magic-number detection only needs the start of the file.\n */\nconst FILE_TYPE_SNIFF_BYTES = 4100;\n\nexport const normalizeDeclaredMime = (mime?: string | null): string =>\n  (mime ?? '').trim().split(';')[0].trim();\n\nexport const isGenericMime = (mime?: string | null): boolean => {\n  const declared = normalizeDeclaredMime(mime);\n\n  return !declared || GENERIC_MIMES.has(declared.toLowerCase());\n};\n\nconst readBlobBytes = async (blob: Blob): Promise<Uint8Array> => {\n  const chunk = typeof blob.slice === 'function' ? blob.slice(0, FILE_TYPE_SNIFF_BYTES) : blob;\n\n  if (typeof chunk.arrayBuffer === 'function') {\n    return new Uint8Array(await chunk.arrayBuffer());\n  }\n\n  // jsdom's Blob.slice() result has no arrayBuffer(); FileReader works in browsers and tests.\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n\n    reader.onload = () => {\n      resolve(new Uint8Array(reader.result as ArrayBuffer));\n    };\n    reader.onerror = () => {\n      reject(reader.error ?? new Error('Failed to read file'));\n    };\n    reader.readAsArrayBuffer(chunk);\n  });\n};\n\n/**\n * Detect MIME from file bytes with file-type.\n * The admin normalizes declared MIME values more permissively; server validation remains authoritative.\n * Returns undefined when the blob cannot be read or the type is unknown.\n */\nexport const detectMimeFromBlob = async (blob: Blob): Promise<string | undefined> => {\n  try {\n    const buffer = await readBlobBytes(blob);\n    // Browser/core build — do not pull the Node `file-type` entry into the admin bundle.\n    const { fileTypeFromBuffer } = await import('file-type/core');\n    const result = await fileTypeFromBuffer(buffer);\n\n    return result?.mime;\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * When the browser MIME is missing or generic, sniff the file contents.\n * If there is no blob (library assets) or detection fails, keep the declared type.\n */\nexport const resolveFileMime = async (\n  mime?: string | null,\n  blob?: Blob | null\n): Promise<string> => {\n  const declared = normalizeDeclaredMime(mime);\n\n  if (declared && !isGenericMime(declared)) {\n    return declared;\n  }\n\n  if (blob) {\n    const detected = await detectMimeFromBlob(blob);\n\n    if (detected) {\n      return detected;\n    }\n  }\n\n  return declared;\n};\n"],"names":["GENERIC_MIMES","Set","FILE_TYPE_SNIFF_BYTES","normalizeDeclaredMime","mime","trim","split","isGenericMime","declared","has","toLowerCase","readBlobBytes","blob","chunk","slice","arrayBuffer","Uint8Array","Promise","resolve","reject","reader","FileReader","onload","result","onerror","error","Error","readAsArrayBuffer","detectMimeFromBlob","buffer","fileTypeFromBuffer","undefined","resolveFileMime","detected"],"mappings":";;AAAA,MAAMA,aAAAA,GAAgB,IAAIC,GAAAA,CAAI;AAAC,IAAA,EAAA;AAAI,IAAA;AAA2B,CAAA,CAAA;AAE9D;;;AAGC,IACD,MAAMC,qBAAAA,GAAwB,IAAA;MAEjBC,qBAAAA,GAAwB,CAACC,OACpC,CAACA,QAAQ,EAAC,EAAGC,IAAI,EAAA,CAAGC,KAAK,CAAC,GAAA,CAAI,CAAC,CAAA,CAAE,CAACD,IAAI;AAEjC,MAAME,gBAAgB,CAACH,IAAAA,GAAAA;AAC5B,IAAA,MAAMI,WAAWL,qBAAAA,CAAsBC,IAAAA,CAAAA;AAEvC,IAAA,OAAO,CAACI,QAAAA,IAAYR,aAAAA,CAAcS,GAAG,CAACD,SAASE,WAAW,EAAA,CAAA;AAC5D;AAEA,MAAMC,gBAAgB,OAAOC,IAAAA,GAAAA;IAC3B,MAAMC,KAAAA,GAAQ,OAAOD,IAAAA,CAAKE,KAAK,KAAK,aAAaF,IAAAA,CAAKE,KAAK,CAAC,CAAA,EAAGZ,qBAAAA,CAAAA,GAAyBU,IAAAA;AAExF,IAAA,IAAI,OAAOC,KAAAA,CAAME,WAAW,KAAK,UAAA,EAAY;AAC3C,QAAA,OAAO,IAAIC,UAAAA,CAAW,MAAMH,KAAAA,CAAME,WAAW,EAAA,CAAA;AAC/C,IAAA;;IAGA,OAAO,IAAIE,OAAAA,CAAQ,CAACC,OAAAA,EAASC,MAAAA,GAAAA;AAC3B,QAAA,MAAMC,SAAS,IAAIC,UAAAA,EAAAA;AAEnBD,QAAAA,MAAAA,CAAOE,MAAM,GAAG,IAAA;YACdJ,OAAAA,CAAQ,IAAIF,UAAAA,CAAWI,MAAAA,CAAOG,MAAM,CAAA,CAAA;AACtC,QAAA,CAAA;AACAH,QAAAA,MAAAA,CAAOI,OAAO,GAAG,IAAA;AACfL,YAAAA,MAAAA,CAAOC,MAAAA,CAAOK,KAAK,IAAI,IAAIC,KAAAA,CAAM,qBAAA,CAAA,CAAA;AACnC,QAAA,CAAA;AACAN,QAAAA,MAAAA,CAAOO,iBAAiB,CAACd,KAAAA,CAAAA;AAC3B,IAAA,CAAA,CAAA;AACF,CAAA;AAEA;;;;IAKO,MAAMe,kBAAAA,GAAqB,OAAOhB,IAAAA,GAAAA;IACvC,IAAI;QACF,MAAMiB,MAAAA,GAAS,MAAMlB,aAAAA,CAAcC,IAAAA,CAAAA;;AAEnC,QAAA,MAAM,EAAEkB,kBAAkB,EAAE,GAAG,MAAM,OAAO,gBAAA,CAAA;QAC5C,MAAMP,MAAAA,GAAS,MAAMO,kBAAAA,CAAmBD,MAAAA,CAAAA;AAExC,QAAA,OAAON,MAAAA,EAAQnB,IAAAA;AACjB,IAAA,CAAA,CAAE,OAAM;QACN,OAAO2B,SAAAA;AACT,IAAA;AACF;AAEA;;;AAGC,IACM,MAAMC,eAAAA,GAAkB,OAC7B5B,IAAAA,EACAQ,IAAAA,GAAAA;AAEA,IAAA,MAAMJ,WAAWL,qBAAAA,CAAsBC,IAAAA,CAAAA;IAEvC,IAAII,QAAAA,IAAY,CAACD,aAAAA,CAAcC,QAAAA,CAAAA,EAAW;QACxC,OAAOA,QAAAA;AACT,IAAA;AAEA,IAAA,IAAII,IAAAA,EAAM;QACR,MAAMqB,QAAAA,GAAW,MAAML,kBAAAA,CAAmBhB,IAAAA,CAAAA;AAE1C,QAAA,IAAIqB,QAAAA,EAAU;YACZ,OAAOA,QAAAA;AACT,QAAA;AACF,IAAA;IAEA,OAAOzB,QAAAA;AACT;;;;;;;"}

package/dist/admin/utils/resolveFileMime.mjs

@@ -0,0 +1,64 @@
+const GENERIC_MIMES = new Set([
+    '',
+    'application/octet-stream'
+]);
+/**
+ * Same byte window currently used by server MIME validation (`readFileChunk(..., 4100)`).
+ * Magic-number detection only needs the start of the file.
+ */ const FILE_TYPE_SNIFF_BYTES = 4100;
+const normalizeDeclaredMime = (mime)=>(mime ?? '').trim().split(';')[0].trim();
+const isGenericMime = (mime)=>{
+    const declared = normalizeDeclaredMime(mime);
+    return !declared || GENERIC_MIMES.has(declared.toLowerCase());
+};
+const readBlobBytes = async (blob)=>{
+    const chunk = typeof blob.slice === 'function' ? blob.slice(0, FILE_TYPE_SNIFF_BYTES) : blob;
+    if (typeof chunk.arrayBuffer === 'function') {
+        return new Uint8Array(await chunk.arrayBuffer());
+    }
+    // jsdom's Blob.slice() result has no arrayBuffer(); FileReader works in browsers and tests.
+    return new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onload = ()=>{
+            resolve(new Uint8Array(reader.result));
+        };
+        reader.onerror = ()=>{
+            reject(reader.error ?? new Error('Failed to read file'));
+        };
+        reader.readAsArrayBuffer(chunk);
+    });
+};
+/**
+ * Detect MIME from file bytes with file-type.
+ * The admin normalizes declared MIME values more permissively; server validation remains authoritative.
+ * Returns undefined when the blob cannot be read or the type is unknown.
+ */ const detectMimeFromBlob = async (blob)=>{
+    try {
+        const buffer = await readBlobBytes(blob);
+        // Browser/core build — do not pull the Node `file-type` entry into the admin bundle.
+        const { fileTypeFromBuffer } = await import('file-type/core');
+        const result = await fileTypeFromBuffer(buffer);
+        return result?.mime;
+    } catch  {
+        return undefined;
+    }
+};
+/**
+ * When the browser MIME is missing or generic, sniff the file contents.
+ * If there is no blob (library assets) or detection fails, keep the declared type.
+ */ const resolveFileMime = async (mime, blob)=>{
+    const declared = normalizeDeclaredMime(mime);
+    if (declared && !isGenericMime(declared)) {
+        return declared;
+    }
+    if (blob) {
+        const detected = await detectMimeFromBlob(blob);
+        if (detected) {
+            return detected;
+        }
+    }
+    return declared;
+};
+
+export { detectMimeFromBlob, isGenericMime, normalizeDeclaredMime, resolveFileMime };
+//# sourceMappingURL=resolveFileMime.mjs.map

package/dist/admin/utils/resolveFileMime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveFileMime.mjs","sources":["../../../admin/src/utils/resolveFileMime.ts"],"sourcesContent":["const GENERIC_MIMES = new Set(['', 'application/octet-stream']);\n\n/**\n * Same byte window currently used by server MIME validation (`readFileChunk(..., 4100)`).\n * Magic-number detection only needs the start of the file.\n */\nconst FILE_TYPE_SNIFF_BYTES = 4100;\n\nexport const normalizeDeclaredMime = (mime?: string | null): string =>\n  (mime ?? '').trim().split(';')[0].trim();\n\nexport const isGenericMime = (mime?: string | null): boolean => {\n  const declared = normalizeDeclaredMime(mime);\n\n  return !declared || GENERIC_MIMES.has(declared.toLowerCase());\n};\n\nconst readBlobBytes = async (blob: Blob): Promise<Uint8Array> => {\n  const chunk = typeof blob.slice === 'function' ? blob.slice(0, FILE_TYPE_SNIFF_BYTES) : blob;\n\n  if (typeof chunk.arrayBuffer === 'function') {\n    return new Uint8Array(await chunk.arrayBuffer());\n  }\n\n  // jsdom's Blob.slice() result has no arrayBuffer(); FileReader works in browsers and tests.\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n\n    reader.onload = () => {\n      resolve(new Uint8Array(reader.result as ArrayBuffer));\n    };\n    reader.onerror = () => {\n      reject(reader.error ?? new Error('Failed to read file'));\n    };\n    reader.readAsArrayBuffer(chunk);\n  });\n};\n\n/**\n * Detect MIME from file bytes with file-type.\n * The admin normalizes declared MIME values more permissively; server validation remains authoritative.\n * Returns undefined when the blob cannot be read or the type is unknown.\n */\nexport const detectMimeFromBlob = async (blob: Blob): Promise<string | undefined> => {\n  try {\n    const buffer = await readBlobBytes(blob);\n    // Browser/core build — do not pull the Node `file-type` entry into the admin bundle.\n    const { fileTypeFromBuffer } = await import('file-type/core');\n    const result = await fileTypeFromBuffer(buffer);\n\n    return result?.mime;\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * When the browser MIME is missing or generic, sniff the file contents.\n * If there is no blob (library assets) or detection fails, keep the declared type.\n */\nexport const resolveFileMime = async (\n  mime?: string | null,\n  blob?: Blob | null\n): Promise<string> => {\n  const declared = normalizeDeclaredMime(mime);\n\n  if (declared && !isGenericMime(declared)) {\n    return declared;\n  }\n\n  if (blob) {\n    const detected = await detectMimeFromBlob(blob);\n\n    if (detected) {\n      return detected;\n    }\n  }\n\n  return declared;\n};\n"],"names":["GENERIC_MIMES","Set","FILE_TYPE_SNIFF_BYTES","normalizeDeclaredMime","mime","trim","split","isGenericMime","declared","has","toLowerCase","readBlobBytes","blob","chunk","slice","arrayBuffer","Uint8Array","Promise","resolve","reject","reader","FileReader","onload","result","onerror","error","Error","readAsArrayBuffer","detectMimeFromBlob","buffer","fileTypeFromBuffer","undefined","resolveFileMime","detected"],"mappings":"AAAA,MAAMA,aAAAA,GAAgB,IAAIC,GAAAA,CAAI;AAAC,IAAA,EAAA;AAAI,IAAA;AAA2B,CAAA,CAAA;AAE9D;;;AAGC,IACD,MAAMC,qBAAAA,GAAwB,IAAA;MAEjBC,qBAAAA,GAAwB,CAACC,OACpC,CAACA,QAAQ,EAAC,EAAGC,IAAI,EAAA,CAAGC,KAAK,CAAC,GAAA,CAAI,CAAC,CAAA,CAAE,CAACD,IAAI;AAEjC,MAAME,gBAAgB,CAACH,IAAAA,GAAAA;AAC5B,IAAA,MAAMI,WAAWL,qBAAAA,CAAsBC,IAAAA,CAAAA;AAEvC,IAAA,OAAO,CAACI,QAAAA,IAAYR,aAAAA,CAAcS,GAAG,CAACD,SAASE,WAAW,EAAA,CAAA;AAC5D;AAEA,MAAMC,gBAAgB,OAAOC,IAAAA,GAAAA;IAC3B,MAAMC,KAAAA,GAAQ,OAAOD,IAAAA,CAAKE,KAAK,KAAK,aAAaF,IAAAA,CAAKE,KAAK,CAAC,CAAA,EAAGZ,qBAAAA,CAAAA,GAAyBU,IAAAA;AAExF,IAAA,IAAI,OAAOC,KAAAA,CAAME,WAAW,KAAK,UAAA,EAAY;AAC3C,QAAA,OAAO,IAAIC,UAAAA,CAAW,MAAMH,KAAAA,CAAME,WAAW,EAAA,CAAA;AAC/C,IAAA;;IAGA,OAAO,IAAIE,OAAAA,CAAQ,CAACC,OAAAA,EAASC,MAAAA,GAAAA;AAC3B,QAAA,MAAMC,SAAS,IAAIC,UAAAA,EAAAA;AAEnBD,QAAAA,MAAAA,CAAOE,MAAM,GAAG,IAAA;YACdJ,OAAAA,CAAQ,IAAIF,UAAAA,CAAWI,MAAAA,CAAOG,MAAM,CAAA,CAAA;AACtC,QAAA,CAAA;AACAH,QAAAA,MAAAA,CAAOI,OAAO,GAAG,IAAA;AACfL,YAAAA,MAAAA,CAAOC,MAAAA,CAAOK,KAAK,IAAI,IAAIC,KAAAA,CAAM,qBAAA,CAAA,CAAA;AACnC,QAAA,CAAA;AACAN,QAAAA,MAAAA,CAAOO,iBAAiB,CAACd,KAAAA,CAAAA;AAC3B,IAAA,CAAA,CAAA;AACF,CAAA;AAEA;;;;IAKO,MAAMe,kBAAAA,GAAqB,OAAOhB,IAAAA,GAAAA;IACvC,IAAI;QACF,MAAMiB,MAAAA,GAAS,MAAMlB,aAAAA,CAAcC,IAAAA,CAAAA;;AAEnC,QAAA,MAAM,EAAEkB,kBAAkB,EAAE,GAAG,MAAM,OAAO,gBAAA,CAAA;QAC5C,MAAMP,MAAAA,GAAS,MAAMO,kBAAAA,CAAmBD,MAAAA,CAAAA;AAExC,QAAA,OAAON,MAAAA,EAAQnB,IAAAA;AACjB,IAAA,CAAA,CAAE,OAAM;QACN,OAAO2B,SAAAA;AACT,IAAA;AACF;AAEA;;;AAGC,IACM,MAAMC,eAAAA,GAAkB,OAC7B5B,IAAAA,EACAQ,IAAAA,GAAAA;AAEA,IAAA,MAAMJ,WAAWL,qBAAAA,CAAsBC,IAAAA,CAAAA;IAEvC,IAAII,QAAAA,IAAY,CAACD,aAAAA,CAAcC,QAAAA,CAAAA,EAAW;QACxC,OAAOA,QAAAA;AACT,IAAA;AAEA,IAAA,IAAII,IAAAA,EAAM;QACR,MAAMqB,QAAAA,GAAW,MAAML,kBAAAA,CAAmBhB,IAAAA,CAAAA;AAE1C,QAAA,IAAIqB,QAAAA,EAAU;YACZ,OAAOA,QAAAA;AACT,QAAA;AACF,IAAA;IAEA,OAAOzB,QAAAA;AACT;;;;"}

package/dist/admin/utils/urlsToAssets.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var resolveFileMime = require('./resolveFileMime.js');
 var typeFromMime = require('./typeFromMime.js');
 
 function getFilenameFromURL(url) {
@@ -22,15 +23,18 @@ const urlsToAssets = async (urls)=>{
         }));
     // Retrieve the assets metadata
     const assetsResults = await Promise.all(assetPromises);
-    const assets = assetsResults.map((fullFilledAsset)=>({
+    const assets = await Promise.all(assetsResults.map(async (fullFilledAsset)=>{
+        const mime = await resolveFileMime.resolveFileMime(fullFilledAsset.mime, fullFilledAsset.rawFile);
+        return {
             source: 'url',
             name: fullFilledAsset.name,
-            type: typeFromMime.typeFromMime(fullFilledAsset.mime),
+            type: typeFromMime.typeFromMime(mime),
             url: fullFilledAsset.url,
             ext: fullFilledAsset.url.split('.').pop(),
-            mime: fullFilledAsset.mime ? fullFilledAsset.mime : undefined,
+            mime: mime || undefined,
             rawFile: fullFilledAsset.rawFile
-        }));
+        };
+    }));
     return assets;
 };
 

package/dist/admin/utils/urlsToAssets.js.map

@@ -1 +1 @@
-{"version":3,"file":"urlsToAssets.js","sources":["../../../admin/src/utils/urlsToAssets.ts"],"sourcesContent":["import { FileWithRawFile } from '../components/UploadAssetDialog/AddAssetStep/AddAssetStep';\n\nimport { typeFromMime } from './typeFromMime';\n\nfunction getFilenameFromURL(url: string) {\n  return new URL(url).pathname.split('/').pop();\n}\n\nexport const urlsToAssets = async (urls: string[]): Promise<FileWithRawFile[]> => {\n  const assetPromises = urls.map((url) =>\n    fetch(url).then(async (res) => {\n      const blob = await res.blob();\n\n      const loadedFile = new File([blob], getFilenameFromURL(res.url)!, {\n        type: res.headers.get('content-type') || undefined,\n      });\n\n      return {\n        name: loadedFile.name,\n        url: res.url,\n        mime: res.headers.get('content-type'),\n        rawFile: loadedFile,\n      };\n    })\n  );\n  // Retrieve the assets metadata\n  const assetsResults = await Promise.all(assetPromises);\n\n  const assets = assetsResults.map<FileWithRawFile>((fullFilledAsset) => ({\n    source: 'url' as const,\n    name: fullFilledAsset.name,\n    type: typeFromMime(fullFilledAsset.mime!),\n    url: fullFilledAsset.url,\n    ext: fullFilledAsset.url.split('.').pop(),\n    mime: fullFilledAsset.mime ? fullFilledAsset.mime : undefined,\n    rawFile: fullFilledAsset.rawFile,\n  }));\n\n  return assets;\n};\n"],"names":["getFilenameFromURL","url","URL","pathname","split","pop","urlsToAssets","urls","assetPromises","map","fetch","then","res","blob","loadedFile","File","type","headers","get","undefined","name","mime","rawFile","assetsResults","Promise","all","assets","fullFilledAsset","source","typeFromMime","ext"],"mappings":";;;;AAIA,SAASA,mBAAmBC,GAAW,EAAA;IACrC,OAAO,IAAIC,IAAID,GAAAA,CAAAA,CAAKE,QAAQ,CAACC,KAAK,CAAC,KAAKC,GAAG,EAAA;AAC7C;AAEO,MAAMC,eAAe,OAAOC,IAAAA,GAAAA;IACjC,MAAMC,aAAAA,GAAgBD,IAAAA,CAAKE,GAAG,CAAC,CAACR,MAC9BS,KAAAA,CAAMT,GAAAA,CAAAA,CAAKU,IAAI,CAAC,OAAOC,GAAAA,GAAAA;YACrB,MAAMC,IAAAA,GAAO,MAAMD,GAAAA,CAAIC,IAAI,EAAA;YAE3B,MAAMC,UAAAA,GAAa,IAAIC,IAAAA,CAAK;AAACF,gBAAAA;aAAK,EAAEb,kBAAAA,CAAmBY,GAAAA,CAAIX,GAAG,CAAA,EAAI;AAChEe,gBAAAA,IAAAA,EAAMJ,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA,IAAmBC;AAC3C,aAAA,CAAA;YAEA,OAAO;AACLC,gBAAAA,IAAAA,EAAMN,WAAWM,IAAI;AACrBnB,gBAAAA,GAAAA,EAAKW,IAAIX,GAAG;AACZoB,gBAAAA,IAAAA,EAAMT,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA;gBACtBI,OAAAA,EAASR;AACX,aAAA;AACF,QAAA,CAAA,CAAA,CAAA;;AAGF,IAAA,MAAMS,aAAAA,GAAgB,MAAMC,OAAAA,CAAQC,GAAG,CAACjB,aAAAA,CAAAA;AAExC,IAAA,MAAMkB,SAASH,aAAAA,CAAcd,GAAG,CAAkB,CAACkB,mBAAqB;YACtEC,MAAAA,EAAQ,KAAA;AACRR,YAAAA,IAAAA,EAAMO,gBAAgBP,IAAI;YAC1BJ,IAAAA,EAAMa,yBAAAA,CAAaF,gBAAgBN,IAAI,CAAA;AACvCpB,YAAAA,GAAAA,EAAK0B,gBAAgB1B,GAAG;AACxB6B,YAAAA,GAAAA,EAAKH,gBAAgB1B,GAAG,CAACG,KAAK,CAAC,KAAKC,GAAG,EAAA;AACvCgB,YAAAA,IAAAA,EAAMM,eAAAA,CAAgBN,IAAI,GAAGM,eAAAA,CAAgBN,IAAI,GAAGF,SAAAA;AACpDG,YAAAA,OAAAA,EAASK,gBAAgBL;SAC3B,CAAA,CAAA;IAEA,OAAOI,MAAAA;AACT;;;;"}
+{"version":3,"file":"urlsToAssets.js","sources":["../../../admin/src/utils/urlsToAssets.ts"],"sourcesContent":["import { FileWithRawFile } from '../components/UploadAssetDialog/AddAssetStep/AddAssetStep';\n\nimport { resolveFileMime } from './resolveFileMime';\nimport { typeFromMime } from './typeFromMime';\n\nfunction getFilenameFromURL(url: string) {\n  return new URL(url).pathname.split('/').pop();\n}\n\nexport const urlsToAssets = async (urls: string[]): Promise<FileWithRawFile[]> => {\n  const assetPromises = urls.map((url) =>\n    fetch(url).then(async (res) => {\n      const blob = await res.blob();\n\n      const loadedFile = new File([blob], getFilenameFromURL(res.url)!, {\n        type: res.headers.get('content-type') || undefined,\n      });\n\n      return {\n        name: loadedFile.name,\n        url: res.url,\n        mime: res.headers.get('content-type'),\n        rawFile: loadedFile,\n      };\n    })\n  );\n  // Retrieve the assets metadata\n  const assetsResults = await Promise.all(assetPromises);\n\n  const assets = await Promise.all(\n    assetsResults.map(async (fullFilledAsset) => {\n      const mime = await resolveFileMime(fullFilledAsset.mime, fullFilledAsset.rawFile);\n\n      return {\n        source: 'url' as const,\n        name: fullFilledAsset.name,\n        type: typeFromMime(mime),\n        url: fullFilledAsset.url,\n        ext: fullFilledAsset.url.split('.').pop(),\n        mime: mime || undefined,\n        rawFile: fullFilledAsset.rawFile,\n      };\n    })\n  );\n\n  return assets;\n};\n"],"names":["getFilenameFromURL","url","URL","pathname","split","pop","urlsToAssets","urls","assetPromises","map","fetch","then","res","blob","loadedFile","File","type","headers","get","undefined","name","mime","rawFile","assetsResults","Promise","all","assets","fullFilledAsset","resolveFileMime","source","typeFromMime","ext"],"mappings":";;;;;AAKA,SAASA,mBAAmBC,GAAW,EAAA;IACrC,OAAO,IAAIC,IAAID,GAAAA,CAAAA,CAAKE,QAAQ,CAACC,KAAK,CAAC,KAAKC,GAAG,EAAA;AAC7C;AAEO,MAAMC,eAAe,OAAOC,IAAAA,GAAAA;IACjC,MAAMC,aAAAA,GAAgBD,IAAAA,CAAKE,GAAG,CAAC,CAACR,MAC9BS,KAAAA,CAAMT,GAAAA,CAAAA,CAAKU,IAAI,CAAC,OAAOC,GAAAA,GAAAA;YACrB,MAAMC,IAAAA,GAAO,MAAMD,GAAAA,CAAIC,IAAI,EAAA;YAE3B,MAAMC,UAAAA,GAAa,IAAIC,IAAAA,CAAK;AAACF,gBAAAA;aAAK,EAAEb,kBAAAA,CAAmBY,GAAAA,CAAIX,GAAG,CAAA,EAAI;AAChEe,gBAAAA,IAAAA,EAAMJ,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA,IAAmBC;AAC3C,aAAA,CAAA;YAEA,OAAO;AACLC,gBAAAA,IAAAA,EAAMN,WAAWM,IAAI;AACrBnB,gBAAAA,GAAAA,EAAKW,IAAIX,GAAG;AACZoB,gBAAAA,IAAAA,EAAMT,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA;gBACtBI,OAAAA,EAASR;AACX,aAAA;AACF,QAAA,CAAA,CAAA,CAAA;;AAGF,IAAA,MAAMS,aAAAA,GAAgB,MAAMC,OAAAA,CAAQC,GAAG,CAACjB,aAAAA,CAAAA;IAExC,MAAMkB,MAAAA,GAAS,MAAMF,OAAAA,CAAQC,GAAG,CAC9BF,aAAAA,CAAcd,GAAG,CAAC,OAAOkB,eAAAA,GAAAA;AACvB,QAAA,MAAMN,OAAO,MAAMO,+BAAAA,CAAgBD,gBAAgBN,IAAI,EAAEM,gBAAgBL,OAAO,CAAA;QAEhF,OAAO;YACLO,MAAAA,EAAQ,KAAA;AACRT,YAAAA,IAAAA,EAAMO,gBAAgBP,IAAI;AAC1BJ,YAAAA,IAAAA,EAAMc,yBAAAA,CAAaT,IAAAA,CAAAA;AACnBpB,YAAAA,GAAAA,EAAK0B,gBAAgB1B,GAAG;AACxB8B,YAAAA,GAAAA,EAAKJ,gBAAgB1B,GAAG,CAACG,KAAK,CAAC,KAAKC,GAAG,EAAA;AACvCgB,YAAAA,IAAAA,EAAMA,IAAAA,IAAQF,SAAAA;AACdG,YAAAA,OAAAA,EAASK,gBAAgBL;AAC3B,SAAA;AACF,IAAA,CAAA,CAAA,CAAA;IAGF,OAAOI,MAAAA;AACT;;;;"}

package/dist/admin/utils/urlsToAssets.mjs

@@ -1,3 +1,4 @@
+import { resolveFileMime } from './resolveFileMime.mjs';
 import { typeFromMime } from './typeFromMime.mjs';
 
 function getFilenameFromURL(url) {
@@ -20,15 +21,18 @@ const urlsToAssets = async (urls)=>{
         }));
     // Retrieve the assets metadata
     const assetsResults = await Promise.all(assetPromises);
-    const assets = assetsResults.map((fullFilledAsset)=>({
+    const assets = await Promise.all(assetsResults.map(async (fullFilledAsset)=>{
+        const mime = await resolveFileMime(fullFilledAsset.mime, fullFilledAsset.rawFile);
+        return {
             source: 'url',
             name: fullFilledAsset.name,
-            type: typeFromMime(fullFilledAsset.mime),
+            type: typeFromMime(mime),
             url: fullFilledAsset.url,
             ext: fullFilledAsset.url.split('.').pop(),
-            mime: fullFilledAsset.mime ? fullFilledAsset.mime : undefined,
+            mime: mime || undefined,
             rawFile: fullFilledAsset.rawFile
-        }));
+        };
+    }));
     return assets;
 };
 

package/dist/admin/utils/urlsToAssets.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"urlsToAssets.mjs","sources":["../../../admin/src/utils/urlsToAssets.ts"],"sourcesContent":["import { FileWithRawFile } from '../components/UploadAssetDialog/AddAssetStep/AddAssetStep';\n\nimport { typeFromMime } from './typeFromMime';\n\nfunction getFilenameFromURL(url: string) {\n  return new URL(url).pathname.split('/').pop();\n}\n\nexport const urlsToAssets = async (urls: string[]): Promise<FileWithRawFile[]> => {\n  const assetPromises = urls.map((url) =>\n    fetch(url).then(async (res) => {\n      const blob = await res.blob();\n\n      const loadedFile = new File([blob], getFilenameFromURL(res.url)!, {\n        type: res.headers.get('content-type') || undefined,\n      });\n\n      return {\n        name: loadedFile.name,\n        url: res.url,\n        mime: res.headers.get('content-type'),\n        rawFile: loadedFile,\n      };\n    })\n  );\n  // Retrieve the assets metadata\n  const assetsResults = await Promise.all(assetPromises);\n\n  const assets = assetsResults.map<FileWithRawFile>((fullFilledAsset) => ({\n    source: 'url' as const,\n    name: fullFilledAsset.name,\n    type: typeFromMime(fullFilledAsset.mime!),\n    url: fullFilledAsset.url,\n    ext: fullFilledAsset.url.split('.').pop(),\n    mime: fullFilledAsset.mime ? fullFilledAsset.mime : undefined,\n    rawFile: fullFilledAsset.rawFile,\n  }));\n\n  return assets;\n};\n"],"names":["getFilenameFromURL","url","URL","pathname","split","pop","urlsToAssets","urls","assetPromises","map","fetch","then","res","blob","loadedFile","File","type","headers","get","undefined","name","mime","rawFile","assetsResults","Promise","all","assets","fullFilledAsset","source","typeFromMime","ext"],"mappings":";;AAIA,SAASA,mBAAmBC,GAAW,EAAA;IACrC,OAAO,IAAIC,IAAID,GAAAA,CAAAA,CAAKE,QAAQ,CAACC,KAAK,CAAC,KAAKC,GAAG,EAAA;AAC7C;AAEO,MAAMC,eAAe,OAAOC,IAAAA,GAAAA;IACjC,MAAMC,aAAAA,GAAgBD,IAAAA,CAAKE,GAAG,CAAC,CAACR,MAC9BS,KAAAA,CAAMT,GAAAA,CAAAA,CAAKU,IAAI,CAAC,OAAOC,GAAAA,GAAAA;YACrB,MAAMC,IAAAA,GAAO,MAAMD,GAAAA,CAAIC,IAAI,EAAA;YAE3B,MAAMC,UAAAA,GAAa,IAAIC,IAAAA,CAAK;AAACF,gBAAAA;aAAK,EAAEb,kBAAAA,CAAmBY,GAAAA,CAAIX,GAAG,CAAA,EAAI;AAChEe,gBAAAA,IAAAA,EAAMJ,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA,IAAmBC;AAC3C,aAAA,CAAA;YAEA,OAAO;AACLC,gBAAAA,IAAAA,EAAMN,WAAWM,IAAI;AACrBnB,gBAAAA,GAAAA,EAAKW,IAAIX,GAAG;AACZoB,gBAAAA,IAAAA,EAAMT,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA;gBACtBI,OAAAA,EAASR;AACX,aAAA;AACF,QAAA,CAAA,CAAA,CAAA;;AAGF,IAAA,MAAMS,aAAAA,GAAgB,MAAMC,OAAAA,CAAQC,GAAG,CAACjB,aAAAA,CAAAA;AAExC,IAAA,MAAMkB,SAASH,aAAAA,CAAcd,GAAG,CAAkB,CAACkB,mBAAqB;YACtEC,MAAAA,EAAQ,KAAA;AACRR,YAAAA,IAAAA,EAAMO,gBAAgBP,IAAI;YAC1BJ,IAAAA,EAAMa,YAAAA,CAAaF,gBAAgBN,IAAI,CAAA;AACvCpB,YAAAA,GAAAA,EAAK0B,gBAAgB1B,GAAG;AACxB6B,YAAAA,GAAAA,EAAKH,gBAAgB1B,GAAG,CAACG,KAAK,CAAC,KAAKC,GAAG,EAAA;AACvCgB,YAAAA,IAAAA,EAAMM,eAAAA,CAAgBN,IAAI,GAAGM,eAAAA,CAAgBN,IAAI,GAAGF,SAAAA;AACpDG,YAAAA,OAAAA,EAASK,gBAAgBL;SAC3B,CAAA,CAAA;IAEA,OAAOI,MAAAA;AACT;;;;"}
+{"version":3,"file":"urlsToAssets.mjs","sources":["../../../admin/src/utils/urlsToAssets.ts"],"sourcesContent":["import { FileWithRawFile } from '../components/UploadAssetDialog/AddAssetStep/AddAssetStep';\n\nimport { resolveFileMime } from './resolveFileMime';\nimport { typeFromMime } from './typeFromMime';\n\nfunction getFilenameFromURL(url: string) {\n  return new URL(url).pathname.split('/').pop();\n}\n\nexport const urlsToAssets = async (urls: string[]): Promise<FileWithRawFile[]> => {\n  const assetPromises = urls.map((url) =>\n    fetch(url).then(async (res) => {\n      const blob = await res.blob();\n\n      const loadedFile = new File([blob], getFilenameFromURL(res.url)!, {\n        type: res.headers.get('content-type') || undefined,\n      });\n\n      return {\n        name: loadedFile.name,\n        url: res.url,\n        mime: res.headers.get('content-type'),\n        rawFile: loadedFile,\n      };\n    })\n  );\n  // Retrieve the assets metadata\n  const assetsResults = await Promise.all(assetPromises);\n\n  const assets = await Promise.all(\n    assetsResults.map(async (fullFilledAsset) => {\n      const mime = await resolveFileMime(fullFilledAsset.mime, fullFilledAsset.rawFile);\n\n      return {\n        source: 'url' as const,\n        name: fullFilledAsset.name,\n        type: typeFromMime(mime),\n        url: fullFilledAsset.url,\n        ext: fullFilledAsset.url.split('.').pop(),\n        mime: mime || undefined,\n        rawFile: fullFilledAsset.rawFile,\n      };\n    })\n  );\n\n  return assets;\n};\n"],"names":["getFilenameFromURL","url","URL","pathname","split","pop","urlsToAssets","urls","assetPromises","map","fetch","then","res","blob","loadedFile","File","type","headers","get","undefined","name","mime","rawFile","assetsResults","Promise","all","assets","fullFilledAsset","resolveFileMime","source","typeFromMime","ext"],"mappings":";;;AAKA,SAASA,mBAAmBC,GAAW,EAAA;IACrC,OAAO,IAAIC,IAAID,GAAAA,CAAAA,CAAKE,QAAQ,CAACC,KAAK,CAAC,KAAKC,GAAG,EAAA;AAC7C;AAEO,MAAMC,eAAe,OAAOC,IAAAA,GAAAA;IACjC,MAAMC,aAAAA,GAAgBD,IAAAA,CAAKE,GAAG,CAAC,CAACR,MAC9BS,KAAAA,CAAMT,GAAAA,CAAAA,CAAKU,IAAI,CAAC,OAAOC,GAAAA,GAAAA;YACrB,MAAMC,IAAAA,GAAO,MAAMD,GAAAA,CAAIC,IAAI,EAAA;YAE3B,MAAMC,UAAAA,GAAa,IAAIC,IAAAA,CAAK;AAACF,gBAAAA;aAAK,EAAEb,kBAAAA,CAAmBY,GAAAA,CAAIX,GAAG,CAAA,EAAI;AAChEe,gBAAAA,IAAAA,EAAMJ,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA,IAAmBC;AAC3C,aAAA,CAAA;YAEA,OAAO;AACLC,gBAAAA,IAAAA,EAAMN,WAAWM,IAAI;AACrBnB,gBAAAA,GAAAA,EAAKW,IAAIX,GAAG;AACZoB,gBAAAA,IAAAA,EAAMT,GAAAA,CAAIK,OAAO,CAACC,GAAG,CAAC,cAAA,CAAA;gBACtBI,OAAAA,EAASR;AACX,aAAA;AACF,QAAA,CAAA,CAAA,CAAA;;AAGF,IAAA,MAAMS,aAAAA,GAAgB,MAAMC,OAAAA,CAAQC,GAAG,CAACjB,aAAAA,CAAAA;IAExC,MAAMkB,MAAAA,GAAS,MAAMF,OAAAA,CAAQC,GAAG,CAC9BF,aAAAA,CAAcd,GAAG,CAAC,OAAOkB,eAAAA,GAAAA;AACvB,QAAA,MAAMN,OAAO,MAAMO,eAAAA,CAAgBD,gBAAgBN,IAAI,EAAEM,gBAAgBL,OAAO,CAAA;QAEhF,OAAO;YACLO,MAAAA,EAAQ,KAAA;AACRT,YAAAA,IAAAA,EAAMO,gBAAgBP,IAAI;AAC1BJ,YAAAA,IAAAA,EAAMc,YAAAA,CAAaT,IAAAA,CAAAA;AACnBpB,YAAAA,GAAAA,EAAK0B,gBAAgB1B,GAAG;AACxB8B,YAAAA,GAAAA,EAAKJ,gBAAgB1B,GAAG,CAACG,KAAK,CAAC,KAAKC,GAAG,EAAA;AACvCgB,YAAAA,IAAAA,EAAMA,IAAAA,IAAQF,SAAAA;AACdG,YAAAA,OAAAA,EAASK,gBAAgBL;AAC3B,SAAA;AACF,IAAA,CAAA,CAAA,CAAA;IAGF,OAAOI,MAAAA;AACT;;;;"}

package/dist/server/services/upload.js

@@ -23,6 +23,16 @@ const { UPDATED_BY_ATTRIBUTE, CREATED_BY_ATTRIBUTE } = utils.contentTypes.consta
 const { MEDIA_CREATE, MEDIA_UPDATE, MEDIA_DELETE } = constants.ALLOWED_WEBHOOK_EVENTS;
 const { ApplicationError, NotFoundError } = utils.errors;
 const { bytesToKbytes } = utils.file;
+/**
+ * Queue a provider operation for a later `Promise.all`, with a rejection handler
+ * attached in the same turn so a fast failure is never an unhandled rejection.
+ *
+ * `Promise.resolve` first — a provider may hand back a plain value, which
+ * `Promise.all` accepts but `.catch` would throw on.
+ */ const queueConcurrentOperation = (queue, operation)=>{
+    Promise.resolve(operation).catch(()=>undefined);
+    queue.push(operation);
+};
 var upload = (({ strapi })=>{
     const fileService = index.getService('file');
     const sendMediaMetrics = async (data)=>{
@@ -218,19 +228,19 @@ var upload = (({ strapi })=>{
         };
         const uploadPromises = [];
         // Upload image
-        uploadPromises.push(index.getService('provider').upload(fileData));
+        queueConcurrentOperation(uploadPromises, index.getService('provider').upload(fileData));
         // Generate & Upload thumbnail and responsive formats
         if (await isResizableImage(fileData)) {
             const thumbnailFile = await generateThumbnail(fileData);
             if (thumbnailFile) {
-                uploadPromises.push(uploadThumbnail(thumbnailFile));
+                queueConcurrentOperation(uploadPromises, uploadThumbnail(thumbnailFile));
             }
             const formats = await generateResponsiveFormats(fileData);
             if (Array.isArray(formats) && formats.length > 0) {
                 for (const format of formats){
                     // eslint-disable-next-line no-continue
                     if (!format) continue;
-                    uploadPromises.push(uploadResponsiveFormat(format));
+                    queueConcurrentOperation(uploadPromises, uploadResponsiveFormat(format));
                 }
             }
         }
@@ -263,13 +273,13 @@ var upload = (({ strapi })=>{
         };
         const promises = [];
         // Replace the main file
-        promises.push(index.getService('provider').replace(fileData, oldFile));
+        queueConcurrentOperation(promises, index.getService('provider').replace(fileData, oldFile));
         const newFormatKeys = new Set();
         if (await isResizableImage(fileData)) {
             const thumbnailFile = await generateThumbnail(fileData);
             if (thumbnailFile) {
                 newFormatKeys.add('thumbnail');
-                promises.push(replaceFormat('thumbnail', thumbnailFile));
+                queueConcurrentOperation(promises, replaceFormat('thumbnail', thumbnailFile));
             }
             const formats = await generateResponsiveFormats(fileData);
             if (Array.isArray(formats) && formats.length > 0) {
@@ -277,7 +287,7 @@ var upload = (({ strapi })=>{
                     // eslint-disable-next-line no-continue
                     if (!format) continue;
                     newFormatKeys.add(format.key);
-                    promises.push(replaceFormat(format.key, format.file));
+                    queueConcurrentOperation(promises, replaceFormat(format.key, format.file));
                 }
             }
         }
@@ -286,7 +296,7 @@ var upload = (({ strapi })=>{
             for (const oldKey of Object.keys(oldFile.formats)){
                 if (!newFormatKeys.has(oldKey)) {
                     const oldFormat = oldFile.formats[oldKey];
-                    promises.push(strapi.plugin('upload').provider.delete(oldFormat));
+                    queueConcurrentOperation(promises, strapi.plugin('upload').provider.delete(oldFormat));
                 }
             }
         }
@@ -616,7 +626,9 @@ var upload = (({ strapi })=>{
         /**
      * exposed for testing only
      * @internal
-     */ _uploadImage: uploadImage
+     */ _uploadImage: uploadImage,
+        _replaceImage: replaceImage,
+        _queueConcurrentOperation: queueConcurrentOperation
     };
 });