payload 3.0.0-beta.7 → 3.0.0-beta.70

package/dist/uploads/getImageSize.js

@@ -1,11 +1,25 @@
 import fs from 'fs';
-import probeImageSize from 'probe-image-size';
-export function getImageSize(file) {
+import sizeOfImport from 'image-size';
+import { promisify } from 'util';
+import { temporaryFileTask } from './tempFile.js';
+const { imageSize } = sizeOfImport;
+const imageSizePromise = promisify(imageSize);
+export async function getImageSize(file) {
     if (file.tempFilePath) {
-        const data = fs.readFileSync(file.tempFilePath);
-        return probeImageSize.sync(data);
+        return imageSizePromise(file.tempFilePath);
     }
-    return probeImageSize.sync(file.data);
+    // Tiff file do not support buffers or streams, so we must write to file first
+    // then retrieve dimensions. https://github.com/image-size/image-size/issues/103
+    if (file.mimetype === 'image/tiff') {
+        const dimensions = await temporaryFileTask(async (filepath)=>{
+            fs.writeFileSync(filepath, file.data);
+            return imageSizePromise(filepath);
+        }, {
+            extension: 'tiff'
+        });
+        return dimensions;
+    }
+    return imageSize(file.data);
 }
 
 //# sourceMappingURL=getImageSize.js.map

package/dist/uploads/getImageSize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/uploads/getImageSize.ts"],"sourcesContent":["import fs from 'fs'\nimport probeImageSize from 'probe-image-size'\n\nimport type { PayloadRequest } from '../types/index.js'\nimport type { ProbedImageSize } from './types.js'\n\nexport function getImageSize(file: PayloadRequest['file']): ProbedImageSize {\n  if (file.tempFilePath) {\n    const data = fs.readFileSync(file.tempFilePath)\n    return probeImageSize.sync(data)\n  }\n\n  return probeImageSize.sync(file.data)\n}\n"],"names":["fs","probeImageSize","getImageSize","file","tempFilePath","data","readFileSync","sync"],"rangeMappings":";;;;;;;;","mappings":"AAAA,OAAOA,QAAQ,KAAI;AACnB,OAAOC,oBAAoB,mBAAkB;AAK7C,OAAO,SAASC,aAAaC,IAA4B;IACvD,IAAIA,KAAKC,YAAY,EAAE;QACrB,MAAMC,OAAOL,GAAGM,YAAY,CAACH,KAAKC,YAAY;QAC9C,OAAOH,eAAeM,IAAI,CAACF;IAC7B;IAEA,OAAOJ,eAAeM,IAAI,CAACJ,KAAKE,IAAI;AACtC"}
+{"version":3,"sources":["../../src/uploads/getImageSize.ts"],"sourcesContent":["import fs from 'fs'\nimport sizeOfImport from 'image-size'\nimport { promisify } from 'util'\n\nimport type { PayloadRequest } from '../types/index.js'\nimport type { ProbedImageSize } from './types.js'\n\nimport { temporaryFileTask } from './tempFile.js'\n\nconst { imageSize } = sizeOfImport\nconst imageSizePromise = promisify(imageSize)\n\nexport async function getImageSize(file: PayloadRequest['file']): Promise<ProbedImageSize> {\n  if (file.tempFilePath) {\n    return imageSizePromise(file.tempFilePath)\n  }\n\n  // Tiff file do not support buffers or streams, so we must write to file first\n  // then retrieve dimensions. https://github.com/image-size/image-size/issues/103\n  if (file.mimetype === 'image/tiff') {\n    const dimensions = await temporaryFileTask(\n      async (filepath: string) => {\n        fs.writeFileSync(filepath, file.data)\n        return imageSizePromise(filepath)\n      },\n      { extension: 'tiff' },\n    )\n    return dimensions\n  }\n\n  return imageSize(file.data)\n}\n"],"names":["fs","sizeOfImport","promisify","temporaryFileTask","imageSize","imageSizePromise","getImageSize","file","tempFilePath","mimetype","dimensions","filepath","writeFileSync","data","extension"],"mappings":"AAAA,OAAOA,QAAQ,KAAI;AACnB,OAAOC,kBAAkB,aAAY;AACrC,SAASC,SAAS,QAAQ,OAAM;AAKhC,SAASC,iBAAiB,QAAQ,gBAAe;AAEjD,MAAM,EAAEC,SAAS,EAAE,GAAGH;AACtB,MAAMI,mBAAmBH,UAAUE;AAEnC,OAAO,eAAeE,aAAaC,IAA4B;IAC7D,IAAIA,KAAKC,YAAY,EAAE;QACrB,OAAOH,iBAAiBE,KAAKC,YAAY;IAC3C;IAEA,8EAA8E;IAC9E,gFAAgF;IAChF,IAAID,KAAKE,QAAQ,KAAK,cAAc;QAClC,MAAMC,aAAa,MAAMP,kBACvB,OAAOQ;YACLX,GAAGY,aAAa,CAACD,UAAUJ,KAAKM,IAAI;YACpC,OAAOR,iBAAiBM;QAC1B,GACA;YAAEG,WAAW;QAAO;QAEtB,OAAOJ;IACT;IAEA,OAAON,UAAUG,KAAKM,IAAI;AAC5B"}

package/dist/uploads/getSafeFilename.d.ts

@@ -5,6 +5,6 @@ type Args = {
     req: PayloadRequest;
     staticPath: string;
 };
-declare function getSafeFileName({ collectionSlug, desiredFilename, req, staticPath, }: Args): Promise<string>;
-export default getSafeFileName;
+export declare function getSafeFileName({ collectionSlug, desiredFilename, req, staticPath, }: Args): Promise<string>;
+export {};
 //# sourceMappingURL=getSafeFilename.d.ts.map

package/dist/uploads/getSafeFilename.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getSafeFilename.d.ts","sourceRoot":"","sources":["../../src/uploads/getSafeFilename.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAsBvD,KAAK,IAAI,GAAG;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,iBAAe,eAAe,CAAC,EAC7B,cAAc,EACd,eAAe,EACf,GAAG,EACH,UAAU,GACX,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBxB;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"getSafeFilename.d.ts","sourceRoot":"","sources":["../../src/uploads/getSafeFilename.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAsBvD,KAAK,IAAI,GAAG;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAsB,eAAe,CAAC,EACpC,cAAc,EACd,eAAe,EACf,GAAG,EACH,UAAU,GACX,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAexB"}

package/dist/uploads/getSafeFilename.js

@@ -17,9 +17,8 @@ const incrementName = (name)=>{
     }
     return `${incrementedName}.${extension}`;
 };
-async function getSafeFileName({ collectionSlug, desiredFilename, req, staticPath }) {
+export async function getSafeFileName({ collectionSlug, desiredFilename, req, staticPath }) {
     let modifiedFilename = desiredFilename;
-    // eslint-disable-next-line no-await-in-loop
     while(await docWithFilenameExists({
         collectionSlug,
         filename: modifiedFilename,
@@ -30,6 +29,5 @@ async function getSafeFileName({ collectionSlug, desiredFilename, req, staticPat
     }
     return modifiedFilename;
 }
-export default getSafeFileName;
 
 //# sourceMappingURL=getSafeFilename.js.map

package/dist/uploads/getSafeFilename.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/uploads/getSafeFilename.ts"],"sourcesContent":["import sanitize from 'sanitize-filename'\n\nimport type { PayloadRequest } from '../types/index.js'\n\nimport docWithFilenameExists from './docWithFilenameExists.js'\nimport fileExists from './fileExists.js'\n\nconst incrementName = (name: string) => {\n  const extension = name.split('.').pop()\n  const baseFilename = sanitize(name.substring(0, name.lastIndexOf('.')) || name)\n  let incrementedName = baseFilename\n  const regex = /(.*)-(\\d+)$/\n  const found = baseFilename.match(regex)\n  if (found === null) {\n    incrementedName += '-1'\n  } else {\n    const matchedName = found[1]\n    const matchedNumber = found[2]\n    const incremented = Number(matchedNumber) + 1\n    incrementedName = `${matchedName}-${incremented}`\n  }\n  return `${incrementedName}.${extension}`\n}\n\ntype Args = {\n  collectionSlug: string\n  desiredFilename: string\n  req: PayloadRequest\n  staticPath: string\n}\n\nasync function getSafeFileName({\n  collectionSlug,\n  desiredFilename,\n  req,\n  staticPath,\n}: Args): Promise<string> {\n  let modifiedFilename = desiredFilename\n\n  // eslint-disable-next-line no-await-in-loop\n  while (\n    (await docWithFilenameExists({\n      collectionSlug,\n      filename: modifiedFilename,\n      path: staticPath,\n      req,\n    })) ||\n    (await fileExists(`${staticPath}/${modifiedFilename}`))\n  ) {\n    modifiedFilename = incrementName(modifiedFilename)\n  }\n  return modifiedFilename\n}\n\nexport default getSafeFileName\n"],"names":["sanitize","docWithFilenameExists","fileExists","incrementName","name","extension","split","pop","baseFilename","substring","lastIndexOf","incrementedName","regex","found","match","matchedName","matchedNumber","incremented","Number","getSafeFileName","collectionSlug","desiredFilename","req","staticPath","modifiedFilename","filename","path"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,cAAc,oBAAmB;AAIxC,OAAOC,2BAA2B,6BAA4B;AAC9D,OAAOC,gBAAgB,kBAAiB;AAExC,MAAMC,gBAAgB,CAACC;IACrB,MAAMC,YAAYD,KAAKE,KAAK,CAAC,KAAKC,GAAG;IACrC,MAAMC,eAAeR,SAASI,KAAKK,SAAS,CAAC,GAAGL,KAAKM,WAAW,CAAC,SAASN;IAC1E,IAAIO,kBAAkBH;IACtB,MAAMI,QAAQ;IACd,MAAMC,QAAQL,aAAaM,KAAK,CAACF;IACjC,IAAIC,UAAU,MAAM;QAClBF,mBAAmB;IACrB,OAAO;QACL,MAAMI,cAAcF,KAAK,CAAC,EAAE;QAC5B,MAAMG,gBAAgBH,KAAK,CAAC,EAAE;QAC9B,MAAMI,cAAcC,OAAOF,iBAAiB;QAC5CL,kBAAkB,CAAC,EAAEI,YAAY,CAAC,EAAEE,YAAY,CAAC;IACnD;IACA,OAAO,CAAC,EAAEN,gBAAgB,CAAC,EAAEN,UAAU,CAAC;AAC1C;AASA,eAAec,gBAAgB,EAC7BC,cAAc,EACdC,eAAe,EACfC,GAAG,EACHC,UAAU,EACL;IACL,IAAIC,mBAAmBH;IAEvB,4CAA4C;IAC5C,MACE,AAAC,MAAMpB,sBAAsB;QAC3BmB;QACAK,UAAUD;QACVE,MAAMH;QACND;IACF,MACC,MAAMpB,WAAW,CAAC,EAAEqB,WAAW,CAAC,EAAEC,iBAAiB,CAAC,EACrD;QACAA,mBAAmBrB,cAAcqB;IACnC;IACA,OAAOA;AACT;AAEA,eAAeL,gBAAe"}
+{"version":3,"sources":["../../src/uploads/getSafeFilename.ts"],"sourcesContent":["import sanitize from 'sanitize-filename'\n\nimport type { PayloadRequest } from '../types/index.js'\n\nimport docWithFilenameExists from './docWithFilenameExists.js'\nimport fileExists from './fileExists.js'\n\nconst incrementName = (name: string) => {\n  const extension = name.split('.').pop()\n  const baseFilename = sanitize(name.substring(0, name.lastIndexOf('.')) || name)\n  let incrementedName = baseFilename\n  const regex = /(.*)-(\\d+)$/\n  const found = baseFilename.match(regex)\n  if (found === null) {\n    incrementedName += '-1'\n  } else {\n    const matchedName = found[1]\n    const matchedNumber = found[2]\n    const incremented = Number(matchedNumber) + 1\n    incrementedName = `${matchedName}-${incremented}`\n  }\n  return `${incrementedName}.${extension}`\n}\n\ntype Args = {\n  collectionSlug: string\n  desiredFilename: string\n  req: PayloadRequest\n  staticPath: string\n}\n\nexport async function getSafeFileName({\n  collectionSlug,\n  desiredFilename,\n  req,\n  staticPath,\n}: Args): Promise<string> {\n  let modifiedFilename = desiredFilename\n\n  while (\n    (await docWithFilenameExists({\n      collectionSlug,\n      filename: modifiedFilename,\n      path: staticPath,\n      req,\n    })) ||\n    (await fileExists(`${staticPath}/${modifiedFilename}`))\n  ) {\n    modifiedFilename = incrementName(modifiedFilename)\n  }\n  return modifiedFilename\n}\n"],"names":["sanitize","docWithFilenameExists","fileExists","incrementName","name","extension","split","pop","baseFilename","substring","lastIndexOf","incrementedName","regex","found","match","matchedName","matchedNumber","incremented","Number","getSafeFileName","collectionSlug","desiredFilename","req","staticPath","modifiedFilename","filename","path"],"mappings":"AAAA,OAAOA,cAAc,oBAAmB;AAIxC,OAAOC,2BAA2B,6BAA4B;AAC9D,OAAOC,gBAAgB,kBAAiB;AAExC,MAAMC,gBAAgB,CAACC;IACrB,MAAMC,YAAYD,KAAKE,KAAK,CAAC,KAAKC,GAAG;IACrC,MAAMC,eAAeR,SAASI,KAAKK,SAAS,CAAC,GAAGL,KAAKM,WAAW,CAAC,SAASN;IAC1E,IAAIO,kBAAkBH;IACtB,MAAMI,QAAQ;IACd,MAAMC,QAAQL,aAAaM,KAAK,CAACF;IACjC,IAAIC,UAAU,MAAM;QAClBF,mBAAmB;IACrB,OAAO;QACL,MAAMI,cAAcF,KAAK,CAAC,EAAE;QAC5B,MAAMG,gBAAgBH,KAAK,CAAC,EAAE;QAC9B,MAAMI,cAAcC,OAAOF,iBAAiB;QAC5CL,kBAAkB,CAAC,EAAEI,YAAY,CAAC,EAAEE,YAAY,CAAC;IACnD;IACA,OAAO,CAAC,EAAEN,gBAAgB,CAAC,EAAEN,UAAU,CAAC;AAC1C;AASA,OAAO,eAAec,gBAAgB,EACpCC,cAAc,EACdC,eAAe,EACfC,GAAG,EACHC,UAAU,EACL;IACL,IAAIC,mBAAmBH;IAEvB,MACE,AAAC,MAAMpB,sBAAsB;QAC3BmB;QACAK,UAAUD;QACVE,MAAMH;QACND;IACF,MACC,MAAMpB,WAAW,CAAC,EAAEqB,WAAW,CAAC,EAAEC,iBAAiB,CAAC,EACrD;QACAA,mBAAmBrB,cAAcqB;IACnC;IACA,OAAOA;AACT"}

package/dist/uploads/imageResizer.d.ts

@@ -1,23 +1,23 @@
 import type { SanitizedCollectionConfig } from '../collections/config/types.js';
 import type { SharpDependency } from '../config/types.js';
-import type { CustomPayloadRequest, PayloadRequest, UploadEdits } from '../types/index.js';
-import type { FileSizes, FileToSave, ProbedImageSize } from './types.js';
+import type { PayloadRequest } from '../types/index.js';
+import type { WithMetadata } from './optionallyAppendMetadata.js';
+import type { FileSizes, FileToSave, ProbedImageSize, UploadEdits } from './types.js';
 type ResizeArgs = {
     config: SanitizedCollectionConfig;
     dimensions: ProbedImageSize;
-    file: CustomPayloadRequest['file'];
+    file: PayloadRequest['file'];
     mimeType: string;
-    req: PayloadRequest & {
-        query?: {
-            uploadEdits?: UploadEdits;
-        };
-    };
+    req: PayloadRequest;
     savedFilename: string;
-    sharp: SharpDependency;
+    sharp?: SharpDependency;
     staticPath: string;
+    uploadEdits?: UploadEdits;
+    withMetadata?: WithMetadata;
 };
 /** Result from resizing and transforming the requested image sizes */
 type ImageSizesResult = {
+    focalPoint?: UploadEdits['focalPoint'];
     sizeData: FileSizes;
     sizesToSave: FileToSave[];
 };
@@ -29,12 +29,12 @@ type ImageSizesResult = {
  *
  * The image will be resized according to the provided
  * resize config. If no image sizes are requested, the resolved data will be empty.
- * For every image that dos not need to be resized, an result object with `null`
+ * For every image that does not need to be resized, a result object with `null`
  * parameters will be returned.
  *
  * @param resizeConfig - the resize config
  * @returns the result of the resize operation(s)
  */
-export default function resizeAndTransformImageSizes({ config, dimensions, file, mimeType, req, savedFilename, sharp, staticPath, }: ResizeArgs): Promise<ImageSizesResult>;
+export declare function resizeAndTransformImageSizes({ config, dimensions, file, mimeType, req, savedFilename, sharp, staticPath, uploadEdits, withMetadata, }: ResizeArgs): Promise<ImageSizesResult>;
 export {};
 //# sourceMappingURL=imageResizer.d.ts.map

package/dist/uploads/imageResizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imageResizer.d.ts","sourceRoot":"","sources":["../../src/uploads/imageResizer.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC1F,OAAO,KAAK,EAAY,SAAS,EAAE,UAAU,EAAa,eAAe,EAAE,MAAM,YAAY,CAAA;AAK7F,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,yBAAyB,CAAA;IACjC,UAAU,EAAE,eAAe,CAAA;IAC3B,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,cAAc,GAAG;QACpB,KAAK,CAAC,EAAE;YACN,WAAW,CAAC,EAAE,WAAW,CAAA;SAC1B,CAAA;KACF,CAAA;IACD,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,eAAe,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,sEAAsE;AACtE,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,SAAS,CAAA;IACnB,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B,CAAA;AAiKD;;;;;;;;;;;;;GAaG;AACH,wBAA8B,4BAA4B,CAAC,EACzD,MAAM,EACN,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,GAAG,EACH,aAAa,EACb,KAAK,EACL,UAAU,GACX,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAkIxC"}
+{"version":3,"file":"imageResizer.d.ts","sourceRoot":"","sources":["../../src/uploads/imageResizer.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAEV,SAAS,EACT,UAAU,EAEV,eAAe,EACf,WAAW,EACZ,MAAM,YAAY,CAAA;AAMnB,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,yBAAyB,CAAA;IACjC,UAAU,EAAE,eAAe,CAAA;IAC3B,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,YAAY,CAAC,EAAE,YAAY,CAAA;CAC5B,CAAA;AAED,sEAAsE;AACtE,KAAK,gBAAgB,GAAG;IACtB,UAAU,CAAC,EAAE,WAAW,CAAC,YAAY,CAAC,CAAA;IACtC,QAAQ,EAAE,SAAS,CAAA;IACnB,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B,CAAA;AAyLD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,4BAA4B,CAAC,EACjD,MAAM,EACN,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,GAAG,EACH,aAAa,EACb,KAAK,EACL,UAAU,EACV,WAAW,EACX,YAAY,GACb,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAyMxC"}

package/dist/uploads/imageResizer.js

@@ -1,9 +1,9 @@
-import fileType from 'file-type';
-const { fromBuffer } = fileType;
+import { fileTypeFromBuffer } from 'file-type';
 import fs from 'fs';
 import sanitize from 'sanitize-filename';
 import { isNumber } from '../utilities/isNumber.js';
 import fileExists from './fileExists.js';
+import { optionallyAppendMetadata } from './optionallyAppendMetadata.js';
 /**
  * Sanitize the image name and extract the extension from the source image
  *
@@ -17,19 +17,9 @@ import fileExists from './fileExists.js';
         ext: extension
     };
 };
-/**
- * Create a new image name based on the output image name, the dimensions and
- * the extension.
- *
- * Ignore the fact that duplicate names could happen if the there is one
- * size with `width AND height` and one with only `height OR width`. Because
- * space is expensive, we will reuse the same image for both sizes.
- *
- * @param outputImageName - the sanitized image name
- * @param bufferInfo - the buffer info
- * @param extension - the extension to use
- * @returns the new image name that is not taken
- */ const createImageName = (outputImageName, { height, width }, extension)=>`${outputImageName}-${width}x${height}.${extension}`;
+const createImageName = ({ extension, height, outputImageName, width })=>{
+    return `${outputImageName}-${width}x${height}.${extension}`;
+};
 /**
  * Create the result object for the image resize operation based on the
  * provided parameters. If the name is not provided, an empty result object
@@ -43,7 +33,8 @@ import fileExists from './fileExists.js';
  * @param mimeType - the mime type of the image
  * @param sizesToSave - the sizes to save
  * @returns the result object
- */ const createResult = (name, filename = null, width = null, height = null, filesize = null, mimeType = null, sizesToSave = [])=>({
+ */ const createResult = ({ name, filename = null, filesize = null, height = null, mimeType = null, sizesToSave = [], width = null })=>{
+    return {
         sizeData: {
             [name]: {
                 filename,
@@ -54,62 +45,43 @@ import fileExists from './fileExists.js';
             }
         },
         sizesToSave
-    });
-/**
- * Check if the image needs to be resized according to the requested dimensions
- * and the original image size. If the resize options withoutEnlargement or withoutReduction are provided,
- * the image will be resized regardless of the requested dimensions, given that the
- * width or height to be resized is provided.
- *
- * @param resizeConfig - object containing the requested dimensions and resize options
- * @param original - the original image size
- * @returns true if resizing is not needed, false otherwise
- */ const preventResize = ({ height: desiredHeight, width: desiredWidth, withoutEnlargement, withoutReduction }, original)=>{
-    // default is to allow reduction
-    if (withoutReduction !== undefined) {
-        return false // needs resize
-        ;
-    }
-    // default is to prevent enlargement
-    if (withoutEnlargement !== undefined) {
-        return false // needs resize
-        ;
-    }
-    const isWidthOrHeightNotDefined = !desiredHeight || !desiredWidth;
-    if (isWidthOrHeightNotDefined) {
-        // If width and height are not defined, it means there is a format conversion
-        // and the image needs to be "resized" (transformed).
-        return false // needs resize
-        ;
-    }
-    const hasInsufficientWidth = desiredWidth > original.width;
-    const hasInsufficientHeight = desiredHeight > original.height;
-    if (hasInsufficientWidth && hasInsufficientHeight) {
-        // doesn't need resize - prevent enlargement. This should only happen if both width and height are insufficient.
-        // if only one dimension is insufficient and the other is sufficient, resizing needs to happen, as the image
-        // should be resized to the sufficient dimension.
-        return true // do not create a new size
-        ;
-    }
-    return false // needs resize
-    ;
+    };
 };
 /**
- * Check if the image should be passed directly to sharp without payload adjusting properties.
+ * Determine whether or not to resize the image.
+ * - resize using image config
+ * - resize using image config with focal adjustments
+ * - do not resize at all
  *
- * @param resizeConfig - object containing the requested dimensions and resize options
- * @param original - the original image size
- * @returns true if the image should passed directly to sharp
- */ const applyPayloadAdjustments = ({ fit, height, width, withoutEnlargement, withoutReduction }, original)=>{
-    if (fit === 'contain' || fit === 'inside') return false;
-    if (!isNumber(height) && !isNumber(width)) return false;
-    const targetAspectRatio = width / height;
-    const originalAspectRatio = original.width / original.height;
-    if (originalAspectRatio === targetAspectRatio) return false;
-    const skipEnlargement = withoutEnlargement && (original.height < height || original.width < width);
-    const skipReduction = withoutReduction && (original.height > height || original.width > width);
-    if (skipEnlargement || skipReduction) return false;
-    return true;
+ * `imageResizeConfig.withoutEnlargement`:
+ * - undefined [default]: uploading images with smaller width AND height than the image size will return null
+ * - false: always enlarge images to the image size
+ * - true: if the image is smaller than the image size, return the original image
+ *
+ * `imageResizeConfig.withoutReduction`:
+ * - false [default]: always enlarge images to the image size
+ * - true: if the image is smaller than the image size, return the original image
+ *
+ * @return 'omit' | 'resize' | 'resizeWithFocalPoint'
+ */ const getImageResizeAction = ({ dimensions: originalImage, hasFocalPoint, imageResizeConfig })=>{
+    const { fit, height: targetHeight, width: targetWidth, withoutEnlargement, withoutReduction } = imageResizeConfig;
+    // prevent upscaling by default when x and y are both smaller than target image size
+    if (targetHeight && targetWidth) {
+        const originalImageIsSmallerXAndY = originalImage.width < targetWidth && originalImage.height < targetHeight;
+        if (withoutEnlargement === undefined && originalImageIsSmallerXAndY) {
+            return 'omit' // prevent image size from being enlarged
+            ;
+        }
+    }
+    const originalImageIsSmallerXOrY = originalImage.width < targetWidth || originalImage.height < targetHeight;
+    if (fit === 'contain' || fit === 'inside') return 'resize';
+    if (!isNumber(targetHeight) && !isNumber(targetWidth)) return 'resize';
+    const targetAspectRatio = targetWidth / targetHeight;
+    const originalAspectRatio = originalImage.width / originalImage.height;
+    if (originalAspectRatio === targetAspectRatio) return 'resize';
+    if (withoutEnlargement && originalImageIsSmallerXOrY) return 'resize';
+    if (withoutReduction && !originalImageIsSmallerXOrY) return 'resize';
+    return hasFocalPoint ? 'resizeWithFocalPoint' : 'resize';
 };
 /**
  * Sanitize the resize config. If the resize config has the `withoutReduction`
@@ -129,6 +101,17 @@ import fileExists from './fileExists.js';
     }
     return resizeConfig;
 };
+/**
+ * Used to extract height from images, animated or not.
+ *
+ * @param sharpMetadata - the sharp metadata
+ * @returns the height of the image
+ */ function extractHeightFromImage(sharpMetadata) {
+    if (sharpMetadata?.pages) {
+        return sharpMetadata.height / sharpMetadata.pages;
+    }
+    return sharpMetadata.height;
+}
 /**
  * For the provided image sizes, handle the resizing and the transforms
  * (format, trim, etc.) of each requested image size and return the result object.
@@ -137,62 +120,118 @@ import fileExists from './fileExists.js';
  *
  * The image will be resized according to the provided
  * resize config. If no image sizes are requested, the resolved data will be empty.
- * For every image that dos not need to be resized, an result object with `null`
+ * For every image that does not need to be resized, a result object with `null`
  * parameters will be returned.
  *
  * @param resizeConfig - the resize config
  * @returns the result of the resize operation(s)
- */ export default async function resizeAndTransformImageSizes({ config, dimensions, file, mimeType, req, savedFilename, sharp, staticPath }) {
-    const { imageSizes } = config.upload;
-    // Noting to resize here so return as early as possible
-    if (!imageSizes) return {
+ */ export async function resizeAndTransformImageSizes({ config, dimensions, file, mimeType, req, savedFilename, sharp, staticPath, uploadEdits, withMetadata }) {
+    const { focalPoint: focalPointEnabled = true, imageSizes } = config.upload;
+    // Focal point adjustments
+    const incomingFocalPoint = uploadEdits.focalPoint ? {
+        x: isNumber(uploadEdits.focalPoint.x) ? Math.round(uploadEdits.focalPoint.x) : 50,
+        y: isNumber(uploadEdits.focalPoint.y) ? Math.round(uploadEdits.focalPoint.y) : 50
+    } : undefined;
+    const defaultResult = {
+        ...focalPointEnabled && incomingFocalPoint && {
+            focalPoint: incomingFocalPoint
+        },
         sizeData: {},
         sizesToSave: []
     };
-    const sharpBase = sharp(file.tempFilePath || file.data).rotate() // pass rotate() to auto-rotate based on EXIF data. https://github.com/payloadcms/payload/pull/3081
+    if (!imageSizes || !sharp) {
+        return defaultResult;
+    }
+    // Determine if the file is animated
+    const fileIsAnimatedType = [
+        'image/avif',
+        'image/gif',
+        'image/webp'
+    ].includes(file.mimetype);
+    const sharpOptions = {};
+    if (fileIsAnimatedType) sharpOptions.animated = true;
+    const sharpBase = sharp(file.tempFilePath || file.data, sharpOptions).rotate() // pass rotate() to auto-rotate based on EXIF data. https://github.com/payloadcms/payload/pull/3081
     ;
+    const originalImageMeta = await sharpBase.metadata();
+    const resizeImageMeta = {
+        height: extractHeightFromImage(originalImageMeta),
+        width: originalImageMeta.width
+    };
     const results = await Promise.all(imageSizes.map(async (imageResizeConfig)=>{
         imageResizeConfig = sanitizeResizeConfig(imageResizeConfig);
-        // This checks if a resize should happen. If not, the resized image will be
-        // skipped COMPLETELY and thus will not be included in the resulting images.
-        // All further format/trim options will thus be skipped as well.
-        if (preventResize(imageResizeConfig, dimensions)) {
-            return createResult(imageResizeConfig.name);
-        }
+        const resizeAction = getImageResizeAction({
+            dimensions,
+            hasFocalPoint: Boolean(incomingFocalPoint),
+            imageResizeConfig
+        });
+        if (resizeAction === 'omit') return createResult({
+            name: imageResizeConfig.name
+        });
         const imageToResize = sharpBase.clone();
         let resized = imageToResize;
-        if (req.query?.uploadEdits?.focalPoint && applyPayloadAdjustments(imageResizeConfig, dimensions)) {
-            const { height: resizeHeight, width: resizeWidth } = imageResizeConfig;
-            const resizeAspectRatio = resizeWidth / resizeHeight;
+        if (resizeAction === 'resizeWithFocalPoint') {
+            let { height: resizeHeight, width: resizeWidth } = imageResizeConfig;
             const originalAspectRatio = dimensions.width / dimensions.height;
+            // Calculate resizeWidth based on original aspect ratio if it's undefined
+            if (resizeHeight && !resizeWidth) {
+                resizeWidth = Math.round(resizeHeight * originalAspectRatio);
+            }
+            // Calculate resizeHeight based on original aspect ratio if it's undefined
+            if (resizeWidth && !resizeHeight) {
+                resizeHeight = Math.round(resizeWidth / originalAspectRatio);
+            }
+            if (!resizeHeight) resizeHeight = resizeImageMeta.height;
+            if (!resizeWidth) resizeWidth = resizeImageMeta.width;
+            const resizeAspectRatio = resizeWidth / resizeHeight;
             const prioritizeHeight = resizeAspectRatio < originalAspectRatio;
-            // Scale the image up or down to fit the resize dimensions
-            const scaledImage = imageToResize.resize({
-                height: prioritizeHeight ? resizeHeight : null,
-                width: prioritizeHeight ? null : resizeWidth
+            // Scales the image before extracting from it
+            resized = imageToResize.resize({
+                height: prioritizeHeight ? resizeHeight : undefined,
+                width: prioritizeHeight ? undefined : resizeWidth
+            });
+            const metadataAppendedFile = await optionallyAppendMetadata({
+                req,
+                sharpFile: resized,
+                withMetadata
             });
-            const { info: scaledImageInfo } = await scaledImage.toBuffer({
+            // Must read from buffer, resized.metadata will return the original image metadata
+            const { info } = await metadataAppendedFile.toBuffer({
                 resolveWithObject: true
             });
-            // Focal point adjustments
-            const focalPoint = {
-                x: isNumber(req.query.uploadEdits.focalPoint?.x) ? req.query.uploadEdits.focalPoint.x : 50,
-                y: isNumber(req.query.uploadEdits.focalPoint?.y) ? req.query.uploadEdits.focalPoint.y : 50
-            };
-            const safeResizeWidth = resizeWidth ?? scaledImageInfo.width;
-            const maxOffsetX = scaledImageInfo.width - safeResizeWidth;
-            const leftFocalEdge = Math.round(scaledImageInfo.width * (focalPoint.x / 100) - safeResizeWidth / 2);
-            const safeOffsetX = Math.min(Math.max(0, leftFocalEdge), maxOffsetX);
-            const safeResizeHeight = resizeHeight ?? scaledImageInfo.height;
-            const maxOffsetY = scaledImageInfo.height - safeResizeHeight;
-            const topFocalEdge = Math.round(scaledImageInfo.height * (focalPoint.y / 100) - safeResizeHeight / 2);
-            const safeOffsetY = Math.min(Math.max(0, topFocalEdge), maxOffsetY);
-            // extract the focal area from the scaled image
-            resized = scaledImage.extract({
-                height: safeResizeHeight,
-                left: safeOffsetX,
-                top: safeOffsetY,
-                width: safeResizeWidth
+            resizeImageMeta.height = extractHeightFromImage({
+                ...originalImageMeta,
+                height: info.height
+            });
+            resizeImageMeta.width = info.width;
+            const halfResizeX = resizeWidth / 2;
+            const xFocalCenter = resizeImageMeta.width * (incomingFocalPoint.x / 100);
+            const calculatedRightPixelBound = xFocalCenter + halfResizeX;
+            let leftBound = xFocalCenter - halfResizeX;
+            // if the right bound is greater than the image width, adjust the left bound
+            // keeping focus on the right
+            if (calculatedRightPixelBound > resizeImageMeta.width) {
+                leftBound = resizeImageMeta.width - resizeWidth;
+            }
+            // if the left bound is less than 0, adjust the left bound to 0
+            // keeping the focus on the left
+            if (leftBound < 0) leftBound = 0;
+            const halfResizeY = resizeHeight / 2;
+            const yFocalCenter = resizeImageMeta.height * (incomingFocalPoint.y / 100);
+            const calculatedBottomPixelBound = yFocalCenter + halfResizeY;
+            let topBound = yFocalCenter - halfResizeY;
+            // if the bottom bound is greater than the image height, adjust the top bound
+            // keeping the image as far right as possible
+            if (calculatedBottomPixelBound > resizeImageMeta.height) {
+                topBound = resizeImageMeta.height - resizeHeight;
+            }
+            // if the top bound is less than 0, adjust the top bound to 0
+            // keeping the image focus near the top
+            if (topBound < 0) topBound = 0;
+            resized = resized.extract({
+                height: resizeHeight,
+                left: Math.floor(leftBound),
+                top: Math.floor(topBound),
+                width: resizeWidth
             });
         } else {
             resized = imageToResize.resize(imageResizeConfig);
@@ -203,13 +242,28 @@ import fileExists from './fileExists.js';
         if (imageResizeConfig.trimOptions) {
             resized = resized.trim(imageResizeConfig.trimOptions);
         }
-        const { data: bufferData, info: bufferInfo } = await resized.toBuffer({
+        const metadataAppendedFile = await optionallyAppendMetadata({
+            req,
+            sharpFile: resized,
+            withMetadata
+        });
+        const { data: bufferData, info: bufferInfo } = await metadataAppendedFile.toBuffer({
             resolveWithObject: true
         });
         const sanitizedImage = getSanitizedImageData(savedFilename);
-        req.payloadUploadSizes[imageResizeConfig.name] = bufferData;
-        const mimeInfo = await fromBuffer(bufferData);
-        const imageNameWithDimensions = createImageName(sanitizedImage.name, bufferInfo, mimeInfo?.ext || sanitizedImage.ext);
+        if (req.payloadUploadSizes) {
+            req.payloadUploadSizes[imageResizeConfig.name] = bufferData;
+        }
+        const mimeInfo = await fileTypeFromBuffer(bufferData);
+        const imageNameWithDimensions = createImageName({
+            extension: mimeInfo?.ext || sanitizedImage.ext,
+            height: extractHeightFromImage({
+                ...originalImageMeta,
+                height: bufferInfo.height
+            }),
+            outputImageName: sanitizedImage.name,
+            width: bufferInfo.width
+        });
         const imagePath = `${staticPath}/${imageNameWithDimensions}`;
         if (await fileExists(imagePath)) {
             try {
@@ -219,20 +273,27 @@ import fileExists from './fileExists.js';
             }
         }
         const { height, size, width } = bufferInfo;
-        return createResult(imageResizeConfig.name, imageNameWithDimensions, width, height, size, mimeInfo?.mime || mimeType, [
-            {
-                buffer: bufferData,
-                path: imagePath
-            }
-        ]);
+        return createResult({
+            name: imageResizeConfig.name,
+            filename: imageNameWithDimensions,
+            filesize: size,
+            height: fileIsAnimatedType && originalImageMeta.pages ? height / originalImageMeta.pages : height,
+            mimeType: mimeInfo?.mime || mimeType,
+            sizesToSave: [
+                {
+                    buffer: bufferData,
+                    path: imagePath
+                }
+            ],
+            width
+        });
     }));
     return results.reduce((acc, result)=>{
         Object.assign(acc.sizeData, result.sizeData);
         acc.sizesToSave.push(...result.sizesToSave);
         return acc;
     }, {
-        sizeData: {},
-        sizesToSave: []
+        ...defaultResult
     });
 }