payload 1.15.7 → 1.15.9

package/packages/payload/dist/uploads/deleteAssociatedFiles.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "deleteAssociatedFiles", {
+    enumerable: true,
+    get: function() {
+        return deleteAssociatedFiles;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _errors = require("../errors");
+const _fileExists = /*#__PURE__*/ _interop_require_default(require("./fileExists"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const deleteAssociatedFiles = async ({ collectionConfig, config, doc, files = [], overrideDelete, t })=>{
+    if (!collectionConfig.upload) return;
+    if (overrideDelete || files.length > 0) {
+        const { staticDir } = collectionConfig.upload;
+        const staticPath = _path.default.resolve(config.paths.configDir, staticDir);
+        const fileToDelete = `${staticPath}/${doc.filename}`;
+        try {
+            if (await (0, _fileExists.default)(fileToDelete)) {
+                _fs.default.unlinkSync(fileToDelete);
+            }
+        } catch (err) {
+            throw new _errors.ErrorDeletingFile(t);
+        }
+        if (doc.sizes) {
+            const sizes = Object.values(doc.sizes);
+            // Since forEach will not wait until unlink is finished it could
+            // happen that two operations will try to delete the same file.
+            // To avoid this it is recommended to use "sync" instead
+            // eslint-disable-next-line no-restricted-syntax
+            for (const size of sizes){
+                const sizeToDelete = `${staticPath}/${size.filename}`;
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    if (await (0, _fileExists.default)(sizeToDelete)) {
+                        _fs.default.unlinkSync(sizeToDelete);
+                    }
+                } catch (err) {
+                    throw new _errors.ErrorDeletingFile(t);
+                }
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/packages/payload/dist/uploads/docWithFilenameExists.d.ts

@@ -0,0 +1,10 @@
+import type { PayloadRequest } from '../express/types';
+type Args = {
+    collectionSlug: string;
+    filename: string;
+    path: string;
+    req: PayloadRequest;
+};
+declare const docWithFilenameExists: ({ collectionSlug, filename, req }: Args) => Promise<boolean>;
+export default docWithFilenameExists;
+//# sourceMappingURL=docWithFilenameExists.d.ts.map

package/packages/payload/dist/uploads/docWithFilenameExists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docWithFilenameExists.d.ts","sourceRoot":"","sources":["../../src/uploads/docWithFilenameExists.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEtD,KAAK,IAAI,GAAG;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,QAAA,MAAM,qBAAqB,sCAA6C,IAAI,KAAG,QAAQ,OAAO,CAa7F,CAAA;AAED,eAAe,qBAAqB,CAAA"}

package/packages/payload/dist/uploads/docWithFilenameExists.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const docWithFilenameExists = async ({ collectionSlug, filename, req })=>{
+    const doc = await req.payload.db.findOne({
+        collection: collectionSlug,
+        req,
+        where: {
+            filename: {
+                equals: filename
+            }
+        }
+    });
+    if (doc) return true;
+    return false;
+};
+const _default = docWithFilenameExists;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91cGxvYWRzL2RvY1dpdGhGaWxlbmFtZUV4aXN0cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFBheWxvYWRSZXF1ZXN0IH0gZnJvbSAnLi4vZXhwcmVzcy90eXBlcydcblxudHlwZSBBcmdzID0ge1xuICBjb2xsZWN0aW9uU2x1Zzogc3RyaW5nXG4gIGZpbGVuYW1lOiBzdHJpbmdcbiAgcGF0aDogc3RyaW5nXG4gIHJlcTogUGF5bG9hZFJlcXVlc3Rcbn1cblxuY29uc3QgZG9jV2l0aEZpbGVuYW1lRXhpc3RzID0gYXN5bmMgKHsgY29sbGVjdGlvblNsdWcsIGZpbGVuYW1lLCByZXEgfTogQXJncyk6IFByb21pc2U8Ym9vbGVhbj4gPT4ge1xuICBjb25zdCBkb2MgPSBhd2FpdCByZXEucGF5bG9hZC5kYi5maW5kT25lKHtcbiAgICBjb2xsZWN0aW9uOiBjb2xsZWN0aW9uU2x1ZyxcbiAgICByZXEsXG4gICAgd2hlcmU6IHtcbiAgICAgIGZpbGVuYW1lOiB7XG4gICAgICAgIGVxdWFsczogZmlsZW5hbWUsXG4gICAgICB9LFxuICAgIH0sXG4gIH0pXG4gIGlmIChkb2MpIHJldHVybiB0cnVlXG5cbiAgcmV0dXJuIGZhbHNlXG59XG5cbmV4cG9ydCBkZWZhdWx0IGRvY1dpdGhGaWxlbmFtZUV4aXN0c1xuIl0sIm5hbWVzIjpbImRvY1dpdGhGaWxlbmFtZUV4aXN0cyIsImNvbGxlY3Rpb25TbHVnIiwiZmlsZW5hbWUiLCJyZXEiLCJkb2MiLCJwYXlsb2FkIiwiZGIiLCJmaW5kT25lIiwiY29sbGVjdGlvbiIsIndoZXJlIiwiZXF1YWxzIl0sInJhbmdlTWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyIsIm1hcHBpbmdzIjoiOzs7OytCQXdCQTs7O2VBQUE7OztBQWZBLE1BQU1BLHdCQUF3QixPQUFPLEVBQUVDLGNBQWMsRUFBRUMsUUFBUSxFQUFFQyxHQUFHLEVBQVE7SUFDMUUsTUFBTUMsTUFBTSxNQUFNRCxJQUFJRSxPQUFPLENBQUNDLEVBQUUsQ0FBQ0MsT0FBTyxDQUFDO1FBQ3ZDQyxZQUFZUDtRQUNaRTtRQUNBTSxPQUFPO1lBQ0xQLFVBQVU7Z0JBQ1JRLFFBQVFSO1lBQ1Y7UUFDRjtJQUNGO0lBQ0EsSUFBSUUsS0FBSyxPQUFPO0lBRWhCLE9BQU87QUFDVDtNQUVBLFdBQWVKIn0=

package/packages/payload/dist/uploads/fileExists.d.ts

@@ -0,0 +1,3 @@
+declare const fileExists: (filename: string) => Promise<boolean>;
+export default fileExists;
+//# sourceMappingURL=fileExists.d.ts.map

package/packages/payload/dist/uploads/fileExists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileExists.d.ts","sourceRoot":"","sources":["../../src/uploads/fileExists.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,UAAU,aAAoB,MAAM,KAAG,QAAQ,OAAO,CAQ3D,CAAA;AAED,eAAe,UAAU,CAAA"}

package/packages/payload/dist/uploads/fileExists.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const fileExists = async (filename)=>{
+    try {
+        await _fs.default.promises.stat(filename);
+        return true;
+    } catch (err) {
+        return false;
+    }
+};
+const _default = fileExists;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91cGxvYWRzL2ZpbGVFeGlzdHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGZzIGZyb20gJ2ZzJ1xuXG5jb25zdCBmaWxlRXhpc3RzID0gYXN5bmMgKGZpbGVuYW1lOiBzdHJpbmcpOiBQcm9taXNlPGJvb2xlYW4+ID0+IHtcbiAgdHJ5IHtcbiAgICBhd2FpdCBmcy5wcm9taXNlcy5zdGF0KGZpbGVuYW1lKVxuXG4gICAgcmV0dXJuIHRydWVcbiAgfSBjYXRjaCAoZXJyKSB7XG4gICAgcmV0dXJuIGZhbHNlXG4gIH1cbn1cblxuZXhwb3J0IGRlZmF1bHQgZmlsZUV4aXN0c1xuIl0sIm5hbWVzIjpbImZpbGVFeGlzdHMiLCJmaWxlbmFtZSIsImZzIiwicHJvbWlzZXMiLCJzdGF0IiwiZXJyIl0sInJhbmdlTWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsiLCJtYXBwaW5ncyI6Ijs7OzsrQkFZQTs7O2VBQUE7OzsyREFaZTs7Ozs7O0FBRWYsTUFBTUEsYUFBYSxPQUFPQztJQUN4QixJQUFJO1FBQ0YsTUFBTUMsV0FBRSxDQUFDQyxRQUFRLENBQUNDLElBQUksQ0FBQ0g7UUFFdkIsT0FBTztJQUNULEVBQUUsT0FBT0ksS0FBSztRQUNaLE9BQU87SUFDVDtBQUNGO01BRUEsV0FBZUwifQ==

package/packages/payload/dist/uploads/formatFilesize.d.ts

@@ -0,0 +1,2 @@
+export default function formatBytes(bytes: number, decimals?: number): string;
+//# sourceMappingURL=formatFilesize.d.ts.map

package/packages/payload/dist/uploads/formatFilesize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatFilesize.d.ts","sourceRoot":"","sources":["../../src/uploads/formatFilesize.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAUvE"}

package/packages/payload/dist/uploads/formatFilesize.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return formatBytes;
+    }
+});
+function formatBytes(bytes, decimals = 0) {
+    if (bytes === 0) return '0 bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = [
+        ' bytes',
+        'KB',
+        'MB',
+        'GB',
+        'TB',
+        'PB',
+        'EB',
+        'ZB',
+        'YB'
+    ];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / k ** i).toFixed(dm))}${sizes[i]}`;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91cGxvYWRzL2Zvcm1hdEZpbGVzaXplLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGZvcm1hdEJ5dGVzKGJ5dGVzOiBudW1iZXIsIGRlY2ltYWxzID0gMCk6IHN0cmluZyB7XG4gIGlmIChieXRlcyA9PT0gMCkgcmV0dXJuICcwIGJ5dGVzJ1xuXG4gIGNvbnN0IGsgPSAxMDI0XG4gIGNvbnN0IGRtID0gZGVjaW1hbHMgPCAwID8gMCA6IGRlY2ltYWxzXG4gIGNvbnN0IHNpemVzID0gWycgYnl0ZXMnLCAnS0InLCAnTUInLCAnR0InLCAnVEInLCAnUEInLCAnRUInLCAnWkInLCAnWUInXVxuXG4gIGNvbnN0IGkgPSBNYXRoLmZsb29yKE1hdGgubG9nKGJ5dGVzKSAvIE1hdGgubG9nKGspKVxuXG4gIHJldHVybiBgJHtwYXJzZUZsb2F0KChieXRlcyAvIGsgKiogaSkudG9GaXhlZChkbSkpfSR7c2l6ZXNbaV19YFxufVxuIl0sIm5hbWVzIjpbImZvcm1hdEJ5dGVzIiwiYnl0ZXMiLCJkZWNpbWFscyIsImsiLCJkbSIsInNpemVzIiwiaSIsIk1hdGgiLCJmbG9vciIsImxvZyIsInBhcnNlRmxvYXQiLCJ0b0ZpeGVkIl0sInJhbmdlTWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsiLCJtYXBwaW5ncyI6Ijs7OzsrQkFBQTs7O2VBQXdCQTs7O0FBQVQsU0FBU0EsWUFBWUMsS0FBYSxFQUFFQyxXQUFXLENBQUM7SUFDN0QsSUFBSUQsVUFBVSxHQUFHLE9BQU87SUFFeEIsTUFBTUUsSUFBSTtJQUNWLE1BQU1DLEtBQUtGLFdBQVcsSUFBSSxJQUFJQTtJQUM5QixNQUFNRyxRQUFRO1FBQUM7UUFBVTtRQUFNO1FBQU07UUFBTTtRQUFNO1FBQU07UUFBTTtRQUFNO0tBQUs7SUFFeEUsTUFBTUMsSUFBSUMsS0FBS0MsS0FBSyxDQUFDRCxLQUFLRSxHQUFHLENBQUNSLFNBQVNNLEtBQUtFLEdBQUcsQ0FBQ047SUFFaEQsT0FBTyxDQUFDLEVBQUVPLFdBQVcsQUFBQ1QsQ0FBQUEsUUFBUUUsS0FBS0csQ0FBQUEsRUFBR0ssT0FBTyxDQUFDUCxLQUFLLEVBQUVDLEtBQUssQ0FBQ0MsRUFBRSxDQUFDLENBQUM7QUFDakUifQ==

package/packages/payload/dist/uploads/generateFileData.d.ts

@@ -0,0 +1,21 @@
+import type { Collection } from '../collections/config/types';
+import type { SanitizedConfig } from '../config/types';
+import type { PayloadRequest } from '../express/types';
+import type { FileToSave } from './types';
+type Args<T> = {
+    collection: Collection;
+    config: SanitizedConfig;
+    data: T;
+    operation: 'create' | 'update';
+    originalDoc?: T;
+    overwriteExistingFiles?: boolean;
+    req: PayloadRequest;
+    throwOnMissingFile?: boolean;
+};
+type Result<T> = Promise<{
+    data: T;
+    files: FileToSave[];
+}>;
+export declare const generateFileData: <T>({ collection: { config: collectionConfig }, config, data, operation, originalDoc, overwriteExistingFiles, req, throwOnMissingFile, }: Args<T>) => Result<T>;
+export {};
+//# sourceMappingURL=generateFileData.d.ts.map

package/packages/payload/dist/uploads/generateFileData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFileData.d.ts","sourceRoot":"","sources":["../../src/uploads/generateFileData.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,KAAK,EAAY,UAAU,EAAgC,MAAM,SAAS,CAAA;AAcjF,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,WAAW,CAAC,EAAE,CAAC,CAAA;IACf,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,KAAK,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAC,CAAA;AAEF,eAAO,MAAM,gBAAgB,iKAiT5B,CAAA"}

package/packages/payload/dist/uploads/generateFileData.js

@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "generateFileData", {
+    enumerable: true,
+    get: function() {
+        return generateFileData;
+    }
+});
+const _filetype = require("file-type");
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _mkdirp = /*#__PURE__*/ _interop_require_default(require("mkdirp"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _sanitizefilename = /*#__PURE__*/ _interop_require_default(require("sanitize-filename"));
+const _sharp = /*#__PURE__*/ _interop_require_default(require("sharp"));
+const _errors = require("../errors");
+const _FileRetrievalError = /*#__PURE__*/ _interop_require_default(require("../errors/FileRetrievalError"));
+const _canResizeImage = /*#__PURE__*/ _interop_require_default(require("./canResizeImage"));
+const _cropImage = require("./cropImage");
+const _getExternalFile = require("./getExternalFile");
+const _getFileByPath = /*#__PURE__*/ _interop_require_default(require("./getFileByPath"));
+const _getImageSize = /*#__PURE__*/ _interop_require_default(require("./getImageSize"));
+const _getSafeFilename = /*#__PURE__*/ _interop_require_default(require("./getSafeFilename"));
+const _imageResizer = /*#__PURE__*/ _interop_require_default(require("./imageResizer"));
+const _isImage = /*#__PURE__*/ _interop_require_default(require("./isImage"));
+const _optionallyAppendMetadata = require("./optionallyAppendMetadata");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const generateFileData = async ({ collection: { config: collectionConfig }, config, data, operation, originalDoc, overwriteExistingFiles, req, throwOnMissingFile })=>{
+    if (!collectionConfig.upload) {
+        return {
+            data,
+            files: []
+        };
+    }
+    let file = req.files?.file || undefined;
+    const uploadEdits = parseUploadEditsFromReqOrIncomingData({
+        data,
+        operation,
+        originalDoc,
+        req
+    });
+    const { disableLocalStorage, focalPoint: focalPointEnabled, formatOptions, imageSizes, resizeOptions, staticDir, trimOptions, withMetadata } = collectionConfig.upload;
+    let staticPath = staticDir;
+    if (staticDir.indexOf('/') !== 0) {
+        staticPath = _path.default.resolve(config.paths.configDir, staticDir);
+    }
+    if (!file && uploadEdits && data) {
+        const { filename, url } = data;
+        try {
+            if (url && url.startsWith('/') && !disableLocalStorage) {
+                const filePath = `${staticPath}/${filename}`;
+                const response = await (0, _getFileByPath.default)(filePath);
+                file = response;
+                overwriteExistingFiles = true;
+            } else if (filename && url) {
+                file = await (0, _getExternalFile.getExternalFile)({
+                    data: data,
+                    req,
+                    uploadConfig: collectionConfig.upload
+                });
+                overwriteExistingFiles = true;
+            }
+        } catch (err) {
+            if (err instanceof Error) {
+                throw new _FileRetrievalError.default(req.t, err.message);
+            }
+        }
+    }
+    if (!file) {
+        if (throwOnMissingFile) throw new _errors.MissingFile(req.t);
+        return {
+            data,
+            files: []
+        };
+    }
+    if (!disableLocalStorage) {
+        _mkdirp.default.sync(staticPath);
+    }
+    let newData = data;
+    const filesToSave = [];
+    const fileData = {};
+    const fileIsAnimatedType = [
+        'image/avif',
+        'image/gif',
+        'image/webp'
+    ].includes(file.mimetype);
+    const cropData = typeof uploadEdits === 'object' && 'crop' in uploadEdits ? uploadEdits.crop : undefined;
+    try {
+        const fileSupportsResize = (0, _canResizeImage.default)(file.mimetype);
+        let fsSafeName;
+        let sharpFile;
+        let dimensions;
+        let fileBuffer;
+        let ext;
+        let mime;
+        const fileHasAdjustments = fileSupportsResize && Boolean(resizeOptions || formatOptions || imageSizes || trimOptions || file.tempFilePath);
+        const sharpOptions = {};
+        if (fileIsAnimatedType) sharpOptions.animated = true;
+        if (_sharp.default && (fileIsAnimatedType || fileHasAdjustments)) {
+            if (file.tempFilePath) {
+                sharpFile = (0, _sharp.default)(file.tempFilePath, sharpOptions).rotate() // pass rotate() to auto-rotate based on EXIF data. https://github.com/payloadcms/payload/pull/3081
+                ;
+            } else {
+                sharpFile = (0, _sharp.default)(file.data, sharpOptions).rotate() // pass rotate() to auto-rotate based on EXIF data. https://github.com/payloadcms/payload/pull/3081
+                ;
+            }
+            if (fileHasAdjustments) {
+                if (resizeOptions) {
+                    sharpFile = sharpFile.resize(resizeOptions);
+                }
+                if (formatOptions) {
+                    sharpFile = sharpFile.toFormat(formatOptions.format, formatOptions.options);
+                }
+                if (trimOptions) {
+                    sharpFile = sharpFile.trim(trimOptions);
+                }
+            }
+        }
+        if (fileSupportsResize || (0, _isImage.default)(file.mimetype)) {
+            dimensions = await (0, _getImageSize.default)(file);
+            fileData.width = dimensions.width;
+            fileData.height = dimensions.height;
+        }
+        if (sharpFile) {
+            const metadata = await sharpFile.metadata();
+            sharpFile = await (0, _optionallyAppendMetadata.optionallyAppendMetadata)({
+                req,
+                sharpFile,
+                withMetadata
+            });
+            fileBuffer = await sharpFile.toBuffer({
+                resolveWithObject: true
+            });
+            ({ ext, mime } = await (0, _filetype.fromBuffer)(fileBuffer.data) // This is getting an incorrect gif height back.
+            );
+            fileData.width = fileBuffer.info.width;
+            fileData.height = fileBuffer.info.height;
+            fileData.filesize = fileBuffer.info.size;
+            // Animated GIFs + WebP aggregate the height from every frame, so we need to use divide by number of pages
+            if (metadata.pages) {
+                fileData.height = fileBuffer.info.height / metadata.pages;
+                fileData.filesize = fileBuffer.data.length;
+            }
+        } else {
+            mime = file.mimetype;
+            fileData.filesize = file.size;
+            if (file.name.includes('.')) {
+                ext = file.name.split('.').pop().split('?')[0];
+            } else {
+                ext = '';
+            }
+        }
+        // Adjust SVG mime type. fromBuffer modifies it.
+        if (mime === 'application/xml' && ext === 'svg') mime = 'image/svg+xml';
+        fileData.mimeType = mime;
+        const baseFilename = (0, _sanitizefilename.default)(file.name.substring(0, file.name.lastIndexOf('.')) || file.name);
+        fsSafeName = `${baseFilename}${ext ? `.${ext}` : ''}`;
+        if (!overwriteExistingFiles) {
+            fsSafeName = await (0, _getSafeFilename.default)({
+                collectionSlug: collectionConfig.slug,
+                desiredFilename: fsSafeName,
+                req,
+                staticPath
+            });
+        }
+        fileData.filename = fsSafeName;
+        let fileForResize = file;
+        if (cropData) {
+            const { data: croppedImage, info } = await (0, _cropImage.cropImage)({
+                cropData,
+                dimensions,
+                file,
+                heightInPixels: uploadEdits.heightInPixels,
+                req,
+                widthInPixels: uploadEdits.widthInPixels,
+                withMetadata
+            });
+            // Apply resize after cropping to ensure it conforms to resizeOptions
+            if (resizeOptions) {
+                const resizedAfterCrop = await (0, _sharp.default)(croppedImage).resize({
+                    fit: resizeOptions?.fit || 'cover',
+                    height: resizeOptions?.height,
+                    position: resizeOptions?.position || 'center',
+                    width: resizeOptions?.width
+                }).toBuffer({
+                    resolveWithObject: true
+                });
+                filesToSave.push({
+                    buffer: resizedAfterCrop.data,
+                    path: `${staticPath}/${fsSafeName}`
+                });
+                fileForResize = {
+                    ...fileForResize,
+                    data: resizedAfterCrop.data,
+                    size: resizedAfterCrop.info.size
+                };
+                fileData.width = resizedAfterCrop.info.width;
+                fileData.height = resizedAfterCrop.info.height;
+                if (fileIsAnimatedType) {
+                    const metadata = await sharpFile.metadata();
+                    fileData.height = metadata.pages ? resizedAfterCrop.info.height / metadata.pages : resizedAfterCrop.info.height;
+                }
+                fileData.filesize = resizedAfterCrop.info.size;
+            } else {
+                // If resizeOptions is not present, just save the cropped image
+                filesToSave.push({
+                    buffer: croppedImage,
+                    path: `${staticPath}/${fsSafeName}`
+                });
+                fileForResize = {
+                    ...file,
+                    data: croppedImage,
+                    size: info.size
+                };
+                fileData.width = info.width;
+                fileData.height = info.height;
+                if (fileIsAnimatedType) {
+                    const metadata = await sharpFile.metadata();
+                    fileData.height = metadata.pages ? info.height / metadata.pages : info.height;
+                }
+                fileData.filesize = info.size;
+            }
+            if (file.tempFilePath) {
+                await _fs.default.promises.writeFile(file.tempFilePath, croppedImage) // write fileBuffer to the temp path
+                ;
+            } else {
+                req.files.file = fileForResize;
+            }
+        } else {
+            filesToSave.push({
+                buffer: fileBuffer?.data || file.data,
+                path: `${staticPath}/${fsSafeName}`
+            });
+            // If using temp files and the image is being resized, write the file to the temp path
+            if (fileBuffer?.data || file.data.length > 0) {
+                if (file.tempFilePath) {
+                    await _fs.default.promises.writeFile(file.tempFilePath, fileBuffer?.data || file.data) // write fileBuffer to the temp path
+                    ;
+                } else {
+                    // Assign the _possibly modified_ file to the request object
+                    req.files.file = {
+                        ...file,
+                        data: fileBuffer?.data || file.data,
+                        size: fileBuffer?.info.size
+                    };
+                }
+            }
+        }
+        if (fileSupportsResize && (Array.isArray(imageSizes) || focalPointEnabled !== false)) {
+            req.payloadUploadSizes = {};
+            const { focalPoint, sizeData, sizesToSave } = await (0, _imageResizer.default)({
+                config: collectionConfig,
+                dimensions: !cropData ? dimensions : {
+                    ...dimensions,
+                    height: fileData.height,
+                    width: fileData.width
+                },
+                file: fileForResize,
+                mimeType: fileData.mimeType,
+                req,
+                savedFilename: fsSafeName || file.name,
+                staticPath,
+                uploadEdits,
+                withMetadata
+            });
+            fileData.sizes = sizeData;
+            fileData.focalX = focalPoint?.x;
+            fileData.focalY = focalPoint?.y;
+            filesToSave.push(...sizesToSave);
+        }
+    } catch (err) {
+        req.payload.logger.error({
+            err,
+            msg: 'Error uploading file'
+        });
+        throw new _errors.FileUploadError(req.t);
+    }
+    newData = {
+        ...newData,
+        ...fileData
+    };
+    return {
+        data: newData,
+        files: filesToSave
+    };
+};
+/**
+ * Parse upload edits from req or incoming data
+ */ function parseUploadEditsFromReqOrIncomingData(args) {
+    const { data, operation, originalDoc, req } = args;
+    // Get intended focal point change from query string or incoming data
+    const uploadEdits = req.query?.uploadEdits && typeof req.query.uploadEdits === 'object' ? req.query.uploadEdits : {};
+    if (uploadEdits.focalPoint) return uploadEdits;
+    const incomingData = data;
+    const origDoc = originalDoc;
+    // If no change in focal point, return undefined.
+    // This prevents a refocal operation triggered from admin, because it always sends the focal point.
+    if (origDoc && incomingData.focalX === origDoc.focalX && incomingData.focalY === origDoc.focalY) {
+        return undefined;
+    }
+    if (incomingData.focalX && incomingData.focalY) {
+        uploadEdits.focalPoint = {
+            x: incomingData.focalX,
+            y: incomingData.focalY
+        };
+        return uploadEdits;
+    }
+    // If no focal point is set, default to center
+    if (operation === 'create') {
+        uploadEdits.focalPoint = {
+            x: 50,
+            y: 50
+        };
+    }
+    return uploadEdits;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/uploads/generateFileData.ts"],"sourcesContent":["import type { UploadedFile } from 'express-fileupload'\nimport type { OutputInfo, Sharp, SharpOptions } from 'sharp'\n\nimport { fromBuffer } from 'file-type'\nimport fs from 'fs'\nimport mkdirp from 'mkdirp'\nimport path from 'path'\nimport sanitize from 'sanitize-filename'\nimport sharp from 'sharp'\n\nimport type { Collection } from '../collections/config/types'\nimport type { SanitizedConfig } from '../config/types'\nimport type { PayloadRequest } from '../express/types'\nimport type { FileData, FileToSave, ProbedImageSize, UploadEdits } from './types'\n\nimport { FileUploadError, MissingFile } from '../errors'\nimport FileRetrievalError from '../errors/FileRetrievalError'\nimport canResizeImage from './canResizeImage'\nimport { cropImage } from './cropImage'\nimport { getExternalFile } from './getExternalFile'\nimport getFileByPath from './getFileByPath'\nimport getImageSize from './getImageSize'\nimport getSafeFileName from './getSafeFilename'\nimport resizeAndTransformImageSizes from './imageResizer'\nimport isImage from './isImage'\nimport { optionallyAppendMetadata } from './optionallyAppendMetadata'\n\ntype Args<T> = {\n  collection: Collection\n  config: SanitizedConfig\n  data: T\n  operation: 'create' | 'update'\n  originalDoc?: T\n  overwriteExistingFiles?: boolean\n  req: PayloadRequest\n  throwOnMissingFile?: boolean\n}\n\ntype Result<T> = Promise<{\n  data: T\n  files: FileToSave[]\n}>\n\nexport const generateFileData = async <T>({\n  collection: { config: collectionConfig },\n  config,\n  data,\n  operation,\n  originalDoc,\n  overwriteExistingFiles,\n  req,\n  throwOnMissingFile,\n}: Args<T>): Result<T> => {\n  if (!collectionConfig.upload) {\n    return {\n      data,\n      files: [],\n    }\n  }\n\n  let file = req.files?.file || undefined\n\n  const uploadEdits = parseUploadEditsFromReqOrIncomingData({\n    data,\n    operation,\n    originalDoc,\n    req,\n  })\n\n  const {\n    disableLocalStorage,\n    focalPoint: focalPointEnabled,\n    formatOptions,\n    imageSizes,\n    resizeOptions,\n    staticDir,\n    trimOptions,\n    withMetadata,\n  } = collectionConfig.upload\n\n  let staticPath = staticDir\n  if (staticDir.indexOf('/') !== 0) {\n    staticPath = path.resolve(config.paths.configDir, staticDir)\n  }\n\n  if (!file && uploadEdits && data) {\n    const { filename, url } = data as FileData\n\n    try {\n      if (url && url.startsWith('/') && !disableLocalStorage) {\n        const filePath = `${staticPath}/${filename}`\n        const response = await getFileByPath(filePath)\n        file = response as UploadedFile\n        overwriteExistingFiles = true\n      } else if (filename && url) {\n        file = (await getExternalFile({\n          data: data as FileData,\n          req,\n          uploadConfig: collectionConfig.upload,\n        })) as UploadedFile\n        overwriteExistingFiles = true\n      }\n    } catch (err: unknown) {\n      if (err instanceof Error) {\n        throw new FileRetrievalError(req.t, err.message)\n      }\n    }\n  }\n\n  if (!file) {\n    if (throwOnMissingFile) throw new MissingFile(req.t)\n\n    return {\n      data,\n      files: [],\n    }\n  }\n\n  if (!disableLocalStorage) {\n    mkdirp.sync(staticPath)\n  }\n\n  let newData = data\n  const filesToSave: FileToSave[] = []\n  const fileData: Partial<FileData> = {}\n  const fileIsAnimatedType = ['image/avif', 'image/gif', 'image/webp'].includes(file.mimetype)\n  const cropData =\n    typeof uploadEdits === 'object' && 'crop' in uploadEdits ? uploadEdits.crop : undefined\n\n  try {\n    const fileSupportsResize = canResizeImage(file.mimetype)\n    let fsSafeName: string\n    let sharpFile: Sharp | undefined\n    let dimensions: ProbedImageSize | undefined\n    let fileBuffer: { data: Buffer; info: OutputInfo }\n    let ext\n    let mime: string\n    const fileHasAdjustments =\n      fileSupportsResize &&\n      Boolean(resizeOptions || formatOptions || imageSizes || trimOptions || file.tempFilePath)\n\n    const sharpOptions: SharpOptions = {}\n\n    if (fileIsAnimatedType) sharpOptions.animated = true\n\n    if (sharp && (fileIsAnimatedType || fileHasAdjustments)) {\n      if (file.tempFilePath) {\n        sharpFile = sharp(file.tempFilePath, sharpOptions).rotate() // pass rotate() to auto-rotate based on EXIF data. https://github.com/payloadcms/payload/pull/3081\n      } else {\n        sharpFile = sharp(file.data, sharpOptions).rotate() // pass rotate() to auto-rotate based on EXIF data. https://github.com/payloadcms/payload/pull/3081\n      }\n\n      if (fileHasAdjustments) {\n        if (resizeOptions) {\n          sharpFile = sharpFile.resize(resizeOptions)\n        }\n        if (formatOptions) {\n          sharpFile = sharpFile.toFormat(formatOptions.format, formatOptions.options)\n        }\n        if (trimOptions) {\n          sharpFile = sharpFile.trim(trimOptions)\n        }\n      }\n    }\n\n    if (fileSupportsResize || isImage(file.mimetype)) {\n      dimensions = await getImageSize(file)\n      fileData.width = dimensions.width\n      fileData.height = dimensions.height\n    }\n\n    if (sharpFile) {\n      const metadata = await sharpFile.metadata()\n      sharpFile = await optionallyAppendMetadata({\n        req,\n        sharpFile,\n        withMetadata,\n      })\n      fileBuffer = await sharpFile.toBuffer({ resolveWithObject: true })\n      ;({ ext, mime } = await fromBuffer(fileBuffer.data)) // This is getting an incorrect gif height back.\n      fileData.width = fileBuffer.info.width\n      fileData.height = fileBuffer.info.height\n      fileData.filesize = fileBuffer.info.size\n\n      // Animated GIFs + WebP aggregate the height from every frame, so we need to use divide by number of pages\n      if (metadata.pages) {\n        fileData.height = fileBuffer.info.height / metadata.pages\n        fileData.filesize = fileBuffer.data.length\n      }\n    } else {\n      mime = file.mimetype\n      fileData.filesize = file.size\n\n      if (file.name.includes('.')) {\n        ext = file.name.split('.').pop().split('?')[0]\n      } else {\n        ext = ''\n      }\n    }\n\n    // Adjust SVG mime type. fromBuffer modifies it.\n    if (mime === 'application/xml' && ext === 'svg') mime = 'image/svg+xml'\n    fileData.mimeType = mime\n\n    const baseFilename = sanitize(file.name.substring(0, file.name.lastIndexOf('.')) || file.name)\n    fsSafeName = `${baseFilename}${ext ? `.${ext}` : ''}`\n\n    if (!overwriteExistingFiles) {\n      fsSafeName = await getSafeFileName({\n        collectionSlug: collectionConfig.slug,\n        desiredFilename: fsSafeName,\n        req,\n        staticPath,\n      })\n    }\n\n    fileData.filename = fsSafeName\n    let fileForResize = file\n\n    if (cropData) {\n      const { data: croppedImage, info } = await cropImage({\n        cropData,\n        dimensions,\n        file,\n        heightInPixels: uploadEdits.heightInPixels,\n        req,\n        widthInPixels: uploadEdits.widthInPixels,\n        withMetadata,\n      })\n\n      // Apply resize after cropping to ensure it conforms to resizeOptions\n      if (resizeOptions) {\n        const resizedAfterCrop = await sharp(croppedImage)\n          .resize({\n            fit: resizeOptions?.fit || 'cover',\n            height: resizeOptions?.height,\n            position: resizeOptions?.position || 'center',\n            width: resizeOptions?.width,\n          })\n          .toBuffer({ resolveWithObject: true })\n\n        filesToSave.push({\n          buffer: resizedAfterCrop.data,\n          path: `${staticPath}/${fsSafeName}`,\n        })\n\n        fileForResize = {\n          ...fileForResize,\n          data: resizedAfterCrop.data,\n          size: resizedAfterCrop.info.size,\n        }\n\n        fileData.width = resizedAfterCrop.info.width\n        fileData.height = resizedAfterCrop.info.height\n        if (fileIsAnimatedType) {\n          const metadata = await sharpFile.metadata()\n          fileData.height = metadata.pages\n            ? resizedAfterCrop.info.height / metadata.pages\n            : resizedAfterCrop.info.height\n        }\n        fileData.filesize = resizedAfterCrop.info.size\n      } else {\n        // If resizeOptions is not present, just save the cropped image\n        filesToSave.push({\n          buffer: croppedImage,\n          path: `${staticPath}/${fsSafeName}`,\n        })\n\n        fileForResize = {\n          ...file,\n          data: croppedImage,\n          size: info.size,\n        }\n\n        fileData.width = info.width\n        fileData.height = info.height\n        if (fileIsAnimatedType) {\n          const metadata = await sharpFile.metadata()\n          fileData.height = metadata.pages ? info.height / metadata.pages : info.height\n        }\n        fileData.filesize = info.size\n      }\n\n      if (file.tempFilePath) {\n        await fs.promises.writeFile(file.tempFilePath, croppedImage) // write fileBuffer to the temp path\n      } else {\n        req.files.file = fileForResize\n      }\n    } else {\n      filesToSave.push({\n        buffer: fileBuffer?.data || file.data,\n        path: `${staticPath}/${fsSafeName}`,\n      })\n\n      // If using temp files and the image is being resized, write the file to the temp path\n      if (fileBuffer?.data || file.data.length > 0) {\n        if (file.tempFilePath) {\n          await fs.promises.writeFile(file.tempFilePath, fileBuffer?.data || file.data) // write fileBuffer to the temp path\n        } else {\n          // Assign the _possibly modified_ file to the request object\n          req.files.file = {\n            ...file,\n            data: fileBuffer?.data || file.data,\n            size: fileBuffer?.info.size,\n          }\n        }\n      }\n    }\n\n    if (fileSupportsResize && (Array.isArray(imageSizes) || focalPointEnabled !== false)) {\n      req.payloadUploadSizes = {}\n      const { focalPoint, sizeData, sizesToSave } = await resizeAndTransformImageSizes({\n        config: collectionConfig,\n        dimensions: !cropData\n          ? dimensions\n          : {\n              ...dimensions,\n              height: fileData.height,\n              width: fileData.width,\n            },\n        file: fileForResize,\n        mimeType: fileData.mimeType,\n        req,\n        savedFilename: fsSafeName || file.name,\n        staticPath,\n        uploadEdits,\n        withMetadata,\n      })\n\n      fileData.sizes = sizeData\n      fileData.focalX = focalPoint?.x\n      fileData.focalY = focalPoint?.y\n      filesToSave.push(...sizesToSave)\n    }\n  } catch (err) {\n    req.payload.logger.error({ err, msg: 'Error uploading file' })\n    throw new FileUploadError(req.t)\n  }\n\n  newData = {\n    ...newData,\n    ...fileData,\n  }\n\n  return {\n    data: newData,\n    files: filesToSave,\n  }\n}\n\n/**\n * Parse upload edits from req or incoming data\n */\nfunction parseUploadEditsFromReqOrIncomingData(args: {\n  data: unknown\n  operation: 'create' | 'update'\n  originalDoc: unknown\n  req: PayloadRequest\n}): UploadEdits {\n  const { data, operation, originalDoc, req } = args\n\n  // Get intended focal point change from query string or incoming data\n  const uploadEdits =\n    req.query?.uploadEdits && typeof req.query.uploadEdits === 'object'\n      ? (req.query.uploadEdits as UploadEdits)\n      : {}\n\n  if (uploadEdits.focalPoint) return uploadEdits\n\n  const incomingData = data as FileData\n  const origDoc = originalDoc as FileData\n\n  // If no change in focal point, return undefined.\n  // This prevents a refocal operation triggered from admin, because it always sends the focal point.\n  if (origDoc && incomingData.focalX === origDoc.focalX && incomingData.focalY === origDoc.focalY) {\n    return undefined\n  }\n\n  if (incomingData.focalX && incomingData.focalY) {\n    uploadEdits.focalPoint = {\n      x: incomingData.focalX,\n      y: incomingData.focalY,\n    }\n    return uploadEdits\n  }\n\n  // If no focal point is set, default to center\n  if (operation === 'create') {\n    uploadEdits.focalPoint = {\n      x: 50,\n      y: 50,\n    }\n  }\n  return uploadEdits\n}\n"],"names":["generateFileData","collection","config","collectionConfig","data","operation","originalDoc","overwriteExistingFiles","req","throwOnMissingFile","upload","files","file","undefined","uploadEdits","parseUploadEditsFromReqOrIncomingData","disableLocalStorage","focalPoint","focalPointEnabled","formatOptions","imageSizes","resizeOptions","staticDir","trimOptions","withMetadata","staticPath","indexOf","path","resolve","paths","configDir","filename","url","startsWith","filePath","response","getFileByPath","getExternalFile","uploadConfig","err","Error","FileRetrievalError","t","message","MissingFile","mkdirp","sync","newData","filesToSave","fileData","fileIsAnimatedType","includes","mimetype","cropData","crop","fileSupportsResize","canResizeImage","fsSafeName","sharpFile","dimensions","fileBuffer","ext","mime","fileHasAdjustments","Boolean","tempFilePath","sharpOptions","animated","sharp","rotate","resize","toFormat","format","options","trim","isImage","getImageSize","width","height","metadata","optionallyAppendMetadata","toBuffer","resolveWithObject","fromBuffer","info","filesize","size","pages","length","name","split","pop","mimeType","baseFilename","sanitize","substring","lastIndexOf","getSafeFileName","collectionSlug","slug","desiredFilename","fileForResize","croppedImage","cropImage","heightInPixels","widthInPixels","resizedAfterCrop","fit","position","push","buffer","fs","promises","writeFile","Array","isArray","payloadUploadSizes","sizeData","sizesToSave","resizeAndTransformImageSizes","savedFilename","sizes","focalX","x","focalY","y","payload","logger","error","msg","FileUploadError","args","query","incomingData","origDoc"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/packages/payload/dist/uploads/getBaseFields.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionConfig } from '../collections/config/types';
+import type { Config } from '../config/types';
+import type { Field } from '../fields/config/types';
+type Options = {
+    collection: CollectionConfig;
+    config: Config;
+};
+declare const getBaseUploadFields: ({ collection, config }: Options) => Field[];
+export default getBaseUploadFields;
+//# sourceMappingURL=getBaseFields.d.ts.map

package/packages/payload/dist/uploads/getBaseFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBaseFields.d.ts","sourceRoot":"","sources":["../../src/uploads/getBaseFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAcnD,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,gBAAgB,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,QAAA,MAAM,mBAAmB,2BAA4B,OAAO,KAAG,KAAK,EAsKnE,CAAA;AAED,eAAe,mBAAmB,CAAA"}