@depup/payload 3.79.1-depup.0

package/dist/uploads/getRangeRequestInfo.d.ts

@@ -0,0 +1,36 @@
+export type RangeRequestResult = {
+    headers: {
+        'Accept-Ranges': string;
+        'Content-Length': string;
+        'Content-Range'?: string;
+    };
+    rangeEnd: number;
+    rangeStart: number;
+    status: 206;
+    type: 'partial';
+} | {
+    headers: {
+        'Accept-Ranges': string;
+        'Content-Length': string;
+    };
+    status: 200;
+    type: 'full';
+} | {
+    headers: {
+        'Content-Range': string;
+    };
+    status: 416;
+    type: 'invalid';
+};
+/**
+ * Gets HTTP Range request information according to RFC 7233
+ *
+ * @param fileSize - The total size of the file in bytes
+ * @param rangeHeader - The Range header value from the request (e.g., "bytes=0-1023")
+ * @returns Result object with headers and status code for the response
+ */
+export declare function getRangeRequestInfo({ fileSize, rangeHeader, }: {
+    fileSize: number;
+    rangeHeader: null | string;
+}): RangeRequestResult;
+//# sourceMappingURL=getRangeRequestInfo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getRangeRequestInfo.d.ts","sourceRoot":"","sources":["../../src/uploads/getRangeRequestInfo.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,kBAAkB,GAC1B;IACE,OAAO,EAAE;QACP,eAAe,EAAE,MAAM,CAAA;QACvB,gBAAgB,EAAE,MAAM,CAAA;QACxB,eAAe,CAAC,EAAE,MAAM,CAAA;KACzB,CAAA;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,GAAG,CAAA;IACX,IAAI,EAAE,SAAS,CAAA;CAChB,GACD;IACE,OAAO,EAAE;QACP,eAAe,EAAE,MAAM,CAAA;QACvB,gBAAgB,EAAE,MAAM,CAAA;KACzB,CAAA;IACD,MAAM,EAAE,GAAG,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,OAAO,EAAE;QACP,eAAe,EAAE,MAAM,CAAA;KACxB,CAAA;IACD,MAAM,EAAE,GAAG,CAAA;IACX,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAEL;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,WAAW,GACZ,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,IAAI,GAAG,MAAM,CAAA;CAC3B,GAAG,kBAAkB,CA6CrB"}

package/dist/uploads/getRangeRequestInfo.js

@@ -0,0 +1,52 @@
+import { status as httpStatus } from 'http-status';
+import { parseRangeHeader } from './parseRangeHeader.js';
+/**
+ * Gets HTTP Range request information according to RFC 7233
+ *
+ * @param fileSize - The total size of the file in bytes
+ * @param rangeHeader - The Range header value from the request (e.g., "bytes=0-1023")
+ * @returns Result object with headers and status code for the response
+ */ export function getRangeRequestInfo({ fileSize, rangeHeader }) {
+    // Parse the Range header
+    const rangeResult = parseRangeHeader({
+        fileSize,
+        rangeHeader
+    });
+    // Handle invalid range
+    if (rangeResult.type === 'invalid') {
+        return {
+            type: 'invalid',
+            headers: {
+                'Content-Range': `bytes */${fileSize}`
+            },
+            status: httpStatus.REQUESTED_RANGE_NOT_SATISFIABLE
+        };
+    }
+    // Handle partial range request
+    if (rangeResult.type === 'partial' && rangeResult.range) {
+        const { end, start } = rangeResult.range;
+        const contentLength = end - start + 1;
+        return {
+            type: 'partial',
+            headers: {
+                'Accept-Ranges': 'bytes',
+                'Content-Length': String(contentLength),
+                'Content-Range': `bytes ${start}-${end}/${fileSize}`
+            },
+            rangeEnd: end,
+            rangeStart: start,
+            status: httpStatus.PARTIAL_CONTENT
+        };
+    }
+    // Handle full file request (no range or invalid)
+    return {
+        type: 'full',
+        headers: {
+            'Accept-Ranges': 'bytes',
+            'Content-Length': String(fileSize)
+        },
+        status: httpStatus.OK
+    };
+}
+
+//# sourceMappingURL=getRangeRequestInfo.js.map

package/dist/uploads/getRangeRequestInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/getRangeRequestInfo.ts"],"sourcesContent":["import { status as httpStatus } from 'http-status'\n\nimport { parseRangeHeader } from './parseRangeHeader.js'\n\nexport type RangeRequestResult =\n  | {\n      headers: {\n        'Accept-Ranges': string\n        'Content-Length': string\n        'Content-Range'?: string\n      }\n      rangeEnd: number\n      rangeStart: number\n      status: 206\n      type: 'partial'\n    }\n  | {\n      headers: {\n        'Accept-Ranges': string\n        'Content-Length': string\n      }\n      status: 200\n      type: 'full'\n    }\n  | {\n      headers: {\n        'Content-Range': string\n      }\n      status: 416\n      type: 'invalid'\n    }\n\n/**\n * Gets HTTP Range request information according to RFC 7233\n *\n * @param fileSize - The total size of the file in bytes\n * @param rangeHeader - The Range header value from the request (e.g., \"bytes=0-1023\")\n * @returns Result object with headers and status code for the response\n */\nexport function getRangeRequestInfo({\n  fileSize,\n  rangeHeader,\n}: {\n  fileSize: number\n  rangeHeader: null | string\n}): RangeRequestResult {\n  // Parse the Range header\n  const rangeResult = parseRangeHeader({\n    fileSize,\n    rangeHeader,\n  })\n\n  // Handle invalid range\n  if (rangeResult.type === 'invalid') {\n    return {\n      type: 'invalid',\n      headers: {\n        'Content-Range': `bytes */${fileSize}`,\n      },\n      status: httpStatus.REQUESTED_RANGE_NOT_SATISFIABLE,\n    }\n  }\n\n  // Handle partial range request\n  if (rangeResult.type === 'partial' && rangeResult.range) {\n    const { end, start } = rangeResult.range\n    const contentLength = end - start + 1\n\n    return {\n      type: 'partial',\n      headers: {\n        'Accept-Ranges': 'bytes',\n        'Content-Length': String(contentLength),\n        'Content-Range': `bytes ${start}-${end}/${fileSize}`,\n      },\n      rangeEnd: end,\n      rangeStart: start,\n      status: httpStatus.PARTIAL_CONTENT,\n    }\n  }\n\n  // Handle full file request (no range or invalid)\n  return {\n    type: 'full',\n    headers: {\n      'Accept-Ranges': 'bytes',\n      'Content-Length': String(fileSize),\n    },\n    status: httpStatus.OK,\n  }\n}\n"],"names":["status","httpStatus","parseRangeHeader","getRangeRequestInfo","fileSize","rangeHeader","rangeResult","type","headers","REQUESTED_RANGE_NOT_SATISFIABLE","range","end","start","contentLength","String","rangeEnd","rangeStart","PARTIAL_CONTENT","OK"],"mappings":"AAAA,SAASA,UAAUC,UAAU,QAAQ,cAAa;AAElD,SAASC,gBAAgB,QAAQ,wBAAuB;AA8BxD;;;;;;CAMC,GACD,OAAO,SAASC,oBAAoB,EAClCC,QAAQ,EACRC,WAAW,EAIZ;IACC,yBAAyB;IACzB,MAAMC,cAAcJ,iBAAiB;QACnCE;QACAC;IACF;IAEA,uBAAuB;IACvB,IAAIC,YAAYC,IAAI,KAAK,WAAW;QAClC,OAAO;YACLA,MAAM;YACNC,SAAS;gBACP,iBAAiB,CAAC,QAAQ,EAAEJ,UAAU;YACxC;YACAJ,QAAQC,WAAWQ,+BAA+B;QACpD;IACF;IAEA,+BAA+B;IAC/B,IAAIH,YAAYC,IAAI,KAAK,aAAaD,YAAYI,KAAK,EAAE;QACvD,MAAM,EAAEC,GAAG,EAAEC,KAAK,EAAE,GAAGN,YAAYI,KAAK;QACxC,MAAMG,gBAAgBF,MAAMC,QAAQ;QAEpC,OAAO;YACLL,MAAM;YACNC,SAAS;gBACP,iBAAiB;gBACjB,kBAAkBM,OAAOD;gBACzB,iBAAiB,CAAC,MAAM,EAAED,MAAM,CAAC,EAAED,IAAI,CAAC,EAAEP,UAAU;YACtD;YACAW,UAAUJ;YACVK,YAAYJ;YACZZ,QAAQC,WAAWgB,eAAe;QACpC;IACF;IAEA,iDAAiD;IACjD,OAAO;QACLV,MAAM;QACNC,SAAS;YACP,iBAAiB;YACjB,kBAAkBM,OAAOV;QAC3B;QACAJ,QAAQC,WAAWiB,EAAE;IACvB;AACF"}

package/dist/uploads/getSafeFilename.d.ts

@@ -0,0 +1,40 @@
+import type { PayloadRequest } from '../types/index.js';
+/**
+ * Increments a filename by appending or incrementing a numeric suffix.
+ * @example
+ * incrementName('file.jpg') // 'file-1.jpg'
+ * incrementName('file-1.jpg') // 'file-2.jpg'
+ * incrementName('file-99.jpg') // 'file-100.jpg'
+ */
+export declare const incrementName: (name: string) => string;
+type Args = {
+    collectionSlug: string;
+    desiredFilename: string;
+    prefix?: string;
+    req: PayloadRequest;
+    staticPath: string;
+};
+/**
+ * Generates a safe, unique filename by checking for conflicts in both the database
+ * and filesystem. If a conflict exists, it increments a numeric suffix until a
+ * unique name is found.
+ *
+ * @param args.collectionSlug - The slug of the upload collection
+ * @param args.desiredFilename - The original filename to make safe
+ * @param args.prefix - Optional prefix path for cloud storage adapters
+ * @param args.req - The Payload request object
+ * @param args.staticPath - The filesystem path where uploads are stored
+ * @returns A unique filename that doesn't conflict with existing files
+ *
+ * @example
+ * // If 'photo.jpg' already exists, returns 'photo-1.jpg'
+ * const safeName = await getSafeFileName({
+ *   collectionSlug: 'media',
+ *   desiredFilename: 'photo.jpg',
+ *   req,
+ *   staticPath: '/uploads/media',
+ * })
+ */
+export declare function getSafeFileName({ collectionSlug, desiredFilename, prefix, req, staticPath, }: Args): Promise<string>;
+export {};
+//# sourceMappingURL=getSafeFilename.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getSafeFilename.d.ts","sourceRoot":"","sources":["../../src/uploads/getSafeFilename.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAKvD;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,SAAU,MAAM,KAAG,MAe5C,CAAA;AAED,KAAK,IAAI,GAAG;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,cAAc,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,eAAe,CAAC,EACpC,cAAc,EACd,eAAe,EACf,MAAM,EACN,GAAG,EACH,UAAU,GACX,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBxB"}

package/dist/uploads/getSafeFilename.js

@@ -0,0 +1,60 @@
+import sanitize from 'sanitize-filename';
+import { docWithFilenameExists } from './docWithFilenameExists.js';
+import { fileExists } from './fileExists.js';
+/**
+ * Increments a filename by appending or incrementing a numeric suffix.
+ * @example
+ * incrementName('file.jpg') // 'file-1.jpg'
+ * incrementName('file-1.jpg') // 'file-2.jpg'
+ * incrementName('file-99.jpg') // 'file-100.jpg'
+ */ export const incrementName = (name)=>{
+    const extension = name.split('.').pop();
+    const baseFilename = sanitize(name.substring(0, name.lastIndexOf('.')) || name);
+    let incrementedName = baseFilename;
+    const regex = /(.*)-(\d+)$/;
+    const found = baseFilename.match(regex);
+    if (found === null) {
+        incrementedName += '-1';
+    } else {
+        const matchedName = found[1];
+        const matchedNumber = found[2];
+        const incremented = Number(matchedNumber) + 1;
+        incrementedName = `${matchedName}-${incremented}`;
+    }
+    return `${incrementedName}.${extension}`;
+};
+/**
+ * Generates a safe, unique filename by checking for conflicts in both the database
+ * and filesystem. If a conflict exists, it increments a numeric suffix until a
+ * unique name is found.
+ *
+ * @param args.collectionSlug - The slug of the upload collection
+ * @param args.desiredFilename - The original filename to make safe
+ * @param args.prefix - Optional prefix path for cloud storage adapters
+ * @param args.req - The Payload request object
+ * @param args.staticPath - The filesystem path where uploads are stored
+ * @returns A unique filename that doesn't conflict with existing files
+ *
+ * @example
+ * // If 'photo.jpg' already exists, returns 'photo-1.jpg'
+ * const safeName = await getSafeFileName({
+ *   collectionSlug: 'media',
+ *   desiredFilename: 'photo.jpg',
+ *   req,
+ *   staticPath: '/uploads/media',
+ * })
+ */ export async function getSafeFileName({ collectionSlug, desiredFilename, prefix, req, staticPath }) {
+    let modifiedFilename = desiredFilename;
+    while(await docWithFilenameExists({
+        collectionSlug,
+        filename: modifiedFilename,
+        path: staticPath,
+        prefix,
+        req
+    }) || await fileExists(`${staticPath}/${modifiedFilename}`)){
+        modifiedFilename = incrementName(modifiedFilename);
+    }
+    return modifiedFilename;
+}
+
+//# sourceMappingURL=getSafeFilename.js.map

package/dist/uploads/getSafeFilename.js.map

@@ -0,0 +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\n/**\n * Increments a filename by appending or incrementing a numeric suffix.\n * @example\n * incrementName('file.jpg') // 'file-1.jpg'\n * incrementName('file-1.jpg') // 'file-2.jpg'\n * incrementName('file-99.jpg') // 'file-100.jpg'\n */\nexport const incrementName = (name: string): 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  prefix?: string\n  req: PayloadRequest\n  staticPath: string\n}\n\n/**\n * Generates a safe, unique filename by checking for conflicts in both the database\n * and filesystem. If a conflict exists, it increments a numeric suffix until a\n * unique name is found.\n *\n * @param args.collectionSlug - The slug of the upload collection\n * @param args.desiredFilename - The original filename to make safe\n * @param args.prefix - Optional prefix path for cloud storage adapters\n * @param args.req - The Payload request object\n * @param args.staticPath - The filesystem path where uploads are stored\n * @returns A unique filename that doesn't conflict with existing files\n *\n * @example\n * // If 'photo.jpg' already exists, returns 'photo-1.jpg'\n * const safeName = await getSafeFileName({\n *   collectionSlug: 'media',\n *   desiredFilename: 'photo.jpg',\n *   req,\n *   staticPath: '/uploads/media',\n * })\n */\nexport async function getSafeFileName({\n  collectionSlug,\n  desiredFilename,\n  prefix,\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      prefix,\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","prefix","req","staticPath","modifiedFilename","filename","path"],"mappings":"AAAA,OAAOA,cAAc,oBAAmB;AAIxC,SAASC,qBAAqB,QAAQ,6BAA4B;AAClE,SAASC,UAAU,QAAQ,kBAAiB;AAE5C;;;;;;CAMC,GACD,OAAO,MAAMC,gBAAgB,CAACC;IAC5B,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,GAAGI,YAAY,CAAC,EAAEE,aAAa;IACnD;IACA,OAAO,GAAGN,gBAAgB,CAAC,EAAEN,WAAW;AAC1C,EAAC;AAUD;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,eAAec,gBAAgB,EACpCC,cAAc,EACdC,eAAe,EACfC,MAAM,EACNC,GAAG,EACHC,UAAU,EACL;IACL,IAAIC,mBAAmBJ;IAEvB,MACE,AAAC,MAAMpB,sBAAsB;QAC3BmB;QACAM,UAAUD;QACVE,MAAMH;QACNF;QACAC;IACF,MACC,MAAMrB,WAAW,GAAGsB,WAAW,CAAC,EAAEC,kBAAkB,EACrD;QACAA,mBAAmBtB,cAAcsB;IACnC;IACA,OAAOA;AACT"}

package/dist/uploads/getSafeFilename.spec.js

@@ -0,0 +1,274 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getSafeFileName, incrementName } from './getSafeFilename.js';
+vi.mock('./docWithFilenameExists.js', ()=>({
+        docWithFilenameExists: vi.fn()
+    }));
+vi.mock('./fileExists.js', ()=>({
+        fileExists: vi.fn()
+    }));
+import { docWithFilenameExists } from './docWithFilenameExists.js';
+import { fileExists } from './fileExists.js';
+const mockDocWithFilenameExists = vi.mocked(docWithFilenameExists);
+const mockFileExists = vi.mocked(fileExists);
+describe('incrementName', ()=>{
+    it('should add -1 suffix to filename without existing suffix', ()=>{
+        expect(incrementName('photo.jpg')).toBe('photo-1.jpg');
+    });
+    it('should increment existing numeric suffix', ()=>{
+        expect(incrementName('photo-1.jpg')).toBe('photo-2.jpg');
+    });
+    it('should handle multi-digit suffixes', ()=>{
+        expect(incrementName('photo-99.jpg')).toBe('photo-100.jpg');
+    });
+    it('should handle filenames with multiple dots', ()=>{
+        expect(incrementName('my.photo.name.jpg')).toBe('my.photo.name-1.jpg');
+    });
+    it('should handle filenames with hyphens but no numeric suffix', ()=>{
+        expect(incrementName('my-photo.jpg')).toBe('my-photo-1.jpg');
+    });
+    it('should handle filenames with hyphens and numeric suffix', ()=>{
+        expect(incrementName('my-photo-5.jpg')).toBe('my-photo-6.jpg');
+    });
+    it('should preserve the original extension', ()=>{
+        expect(incrementName('document.pdf')).toBe('document-1.pdf');
+        expect(incrementName('image.png')).toBe('image-1.png');
+    });
+    it('should handle files with long extensions', ()=>{
+        expect(incrementName('archive.tar.gz')).toBe('archive.tar-1.gz');
+    });
+    it('should handle filename with no extension', ()=>{
+        expect(incrementName('filename')).toBe('filename-1.filename');
+    });
+    it('should handle filename that is just an extension', ()=>{
+        expect(incrementName('.gitignore')).toBe('.gitignore-1.gitignore');
+    });
+    it('should handle empty string', ()=>{
+        expect(incrementName('')).toBe('-1.');
+    });
+    it('should handle filename ending with hyphen and non-numeric', ()=>{
+        expect(incrementName('file-abc.jpg')).toBe('file-abc-1.jpg');
+    });
+    it('should handle filename with only numbers before extension', ()=>{
+        expect(incrementName('12345.jpg')).toBe('12345-1.jpg');
+    });
+    it('should handle filename where base ends with -0', ()=>{
+        expect(incrementName('file-0.jpg')).toBe('file-1.jpg');
+    });
+    it('should preserve jpeg extension', ()=>{
+        expect(incrementName('photo.jpeg')).toBe('photo-1.jpeg');
+        expect(incrementName('photo-1.jpeg')).toBe('photo-2.jpeg');
+    });
+    it('should preserve jpg extension', ()=>{
+        expect(incrementName('photo.jpg')).toBe('photo-1.jpg');
+        expect(incrementName('photo-1.jpg')).toBe('photo-2.jpg');
+    });
+    it('should preserve tiff extension', ()=>{
+        expect(incrementName('image.tiff')).toBe('image-1.tiff');
+        expect(incrementName('image-1.tiff')).toBe('image-2.tiff');
+    });
+    it('should preserve tif extension', ()=>{
+        expect(incrementName('image.tif')).toBe('image-1.tif');
+        expect(incrementName('image-1.tif')).toBe('image-2.tif');
+    });
+    it('should handle common image formats', ()=>{
+        expect(incrementName('image.png')).toBe('image-1.png');
+        expect(incrementName('image.gif')).toBe('image-1.gif');
+        expect(incrementName('image.webp')).toBe('image-1.webp');
+        expect(incrementName('image.avif')).toBe('image-1.avif');
+        expect(incrementName('image.svg')).toBe('image-1.svg');
+        expect(incrementName('image.bmp')).toBe('image-1.bmp');
+        expect(incrementName('image.ico')).toBe('image-1.ico');
+    });
+    it('should handle common document formats', ()=>{
+        expect(incrementName('document.pdf')).toBe('document-1.pdf');
+        expect(incrementName('document.doc')).toBe('document-1.doc');
+        expect(incrementName('document.docx')).toBe('document-1.docx');
+        expect(incrementName('spreadsheet.xls')).toBe('spreadsheet-1.xls');
+        expect(incrementName('spreadsheet.xlsx')).toBe('spreadsheet-1.xlsx');
+        expect(incrementName('presentation.ppt')).toBe('presentation-1.ppt');
+        expect(incrementName('presentation.pptx')).toBe('presentation-1.pptx');
+    });
+    it('should handle common video formats', ()=>{
+        expect(incrementName('video.mp4')).toBe('video-1.mp4');
+        expect(incrementName('video.mov')).toBe('video-1.mov');
+        expect(incrementName('video.avi')).toBe('video-1.avi');
+        expect(incrementName('video.webm')).toBe('video-1.webm');
+        expect(incrementName('video.mkv')).toBe('video-1.mkv');
+    });
+    it('should handle common audio formats', ()=>{
+        expect(incrementName('audio.mp3')).toBe('audio-1.mp3');
+        expect(incrementName('audio.wav')).toBe('audio-1.wav');
+        expect(incrementName('audio.ogg')).toBe('audio-1.ogg');
+        expect(incrementName('audio.flac')).toBe('audio-1.flac');
+        expect(incrementName('audio.aac')).toBe('audio-1.aac');
+    });
+    it('should handle uppercase extensions', ()=>{
+        expect(incrementName('PHOTO.JPG')).toBe('PHOTO-1.JPG');
+        expect(incrementName('PHOTO.JPEG')).toBe('PHOTO-1.JPEG');
+        expect(incrementName('IMAGE.PNG')).toBe('IMAGE-1.PNG');
+    });
+    it('should handle mixed case extensions', ()=>{
+        expect(incrementName('photo.Jpeg')).toBe('photo-1.Jpeg');
+        expect(incrementName('image.Png')).toBe('image-1.Png');
+    });
+});
+describe('getSafeFileName', ()=>{
+    const mockReq = {};
+    beforeEach(()=>{
+        vi.clearAllMocks();
+    });
+    it('should return original filename when no conflicts exist', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValue(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpg',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('photo.jpg');
+        expect(mockDocWithFilenameExists).toHaveBeenCalledTimes(1);
+        expect(mockFileExists).toHaveBeenCalledTimes(1);
+    });
+    it('should increment filename when document exists in database', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpg',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('photo-1.jpg');
+    });
+    it('should increment filename when file exists on filesystem', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValue(false);
+        mockFileExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpg',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('photo-1.jpg');
+    });
+    it('should keep incrementing until unique name is found', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(true).mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpg',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('photo-3.jpg');
+    });
+    it('should handle conflicts from both database and filesystem', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpg',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('photo-2.jpg');
+    });
+    it('should pass prefix to docWithFilenameExists', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValue(false);
+        mockFileExists.mockResolvedValue(false);
+        await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpg',
+            prefix: 'images/',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(mockDocWithFilenameExists).toHaveBeenCalledWith({
+            collectionSlug: 'media',
+            filename: 'photo.jpg',
+            path: '/uploads',
+            prefix: 'images/',
+            req: mockReq
+        });
+    });
+    it('should check correct filesystem path', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValue(false);
+        mockFileExists.mockResolvedValue(false);
+        await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpg',
+            req: mockReq,
+            staticPath: '/var/uploads/media'
+        });
+        expect(mockFileExists).toHaveBeenCalledWith('/var/uploads/media/photo.jpg');
+    });
+    it('should handle filename that already has numeric suffix', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo-5.jpg',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('photo-6.jpg');
+    });
+    it('should preserve jpeg extension when incrementing', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'photo.jpeg',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('photo-1.jpeg');
+    });
+    it('should preserve tiff extension when incrementing', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'image.tiff',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('image-1.tiff');
+    });
+    it('should handle webp files', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'image.webp',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('image-1.webp');
+    });
+    it('should handle pdf files', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'document.pdf',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('document-1.pdf');
+    });
+    it('should handle mp4 video files', async ()=>{
+        mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+        mockFileExists.mockResolvedValue(false);
+        const result = await getSafeFileName({
+            collectionSlug: 'media',
+            desiredFilename: 'video.mp4',
+            req: mockReq,
+            staticPath: '/uploads'
+        });
+        expect(result).toBe('video-1.mp4');
+    });
+});
+
+//# sourceMappingURL=getSafeFilename.spec.js.map

package/dist/uploads/getSafeFilename.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/getSafeFilename.spec.ts"],"sourcesContent":["import { beforeEach, describe, expect, it, vi } from 'vitest'\n\nimport { getSafeFileName, incrementName } from './getSafeFilename.js'\n\nvi.mock('./docWithFilenameExists.js', () => ({\n  docWithFilenameExists: vi.fn(),\n}))\n\nvi.mock('./fileExists.js', () => ({\n  fileExists: vi.fn(),\n}))\n\nimport { docWithFilenameExists } from './docWithFilenameExists.js'\nimport { fileExists } from './fileExists.js'\n\nconst mockDocWithFilenameExists = vi.mocked(docWithFilenameExists)\nconst mockFileExists = vi.mocked(fileExists)\n\ndescribe('incrementName', () => {\n  it('should add -1 suffix to filename without existing suffix', () => {\n    expect(incrementName('photo.jpg')).toBe('photo-1.jpg')\n  })\n\n  it('should increment existing numeric suffix', () => {\n    expect(incrementName('photo-1.jpg')).toBe('photo-2.jpg')\n  })\n\n  it('should handle multi-digit suffixes', () => {\n    expect(incrementName('photo-99.jpg')).toBe('photo-100.jpg')\n  })\n\n  it('should handle filenames with multiple dots', () => {\n    expect(incrementName('my.photo.name.jpg')).toBe('my.photo.name-1.jpg')\n  })\n\n  it('should handle filenames with hyphens but no numeric suffix', () => {\n    expect(incrementName('my-photo.jpg')).toBe('my-photo-1.jpg')\n  })\n\n  it('should handle filenames with hyphens and numeric suffix', () => {\n    expect(incrementName('my-photo-5.jpg')).toBe('my-photo-6.jpg')\n  })\n\n  it('should preserve the original extension', () => {\n    expect(incrementName('document.pdf')).toBe('document-1.pdf')\n    expect(incrementName('image.png')).toBe('image-1.png')\n  })\n\n  it('should handle files with long extensions', () => {\n    expect(incrementName('archive.tar.gz')).toBe('archive.tar-1.gz')\n  })\n\n  it('should handle filename with no extension', () => {\n    expect(incrementName('filename')).toBe('filename-1.filename')\n  })\n\n  it('should handle filename that is just an extension', () => {\n    expect(incrementName('.gitignore')).toBe('.gitignore-1.gitignore')\n  })\n\n  it('should handle empty string', () => {\n    expect(incrementName('')).toBe('-1.')\n  })\n\n  it('should handle filename ending with hyphen and non-numeric', () => {\n    expect(incrementName('file-abc.jpg')).toBe('file-abc-1.jpg')\n  })\n\n  it('should handle filename with only numbers before extension', () => {\n    expect(incrementName('12345.jpg')).toBe('12345-1.jpg')\n  })\n\n  it('should handle filename where base ends with -0', () => {\n    expect(incrementName('file-0.jpg')).toBe('file-1.jpg')\n  })\n\n  it('should preserve jpeg extension', () => {\n    expect(incrementName('photo.jpeg')).toBe('photo-1.jpeg')\n    expect(incrementName('photo-1.jpeg')).toBe('photo-2.jpeg')\n  })\n\n  it('should preserve jpg extension', () => {\n    expect(incrementName('photo.jpg')).toBe('photo-1.jpg')\n    expect(incrementName('photo-1.jpg')).toBe('photo-2.jpg')\n  })\n\n  it('should preserve tiff extension', () => {\n    expect(incrementName('image.tiff')).toBe('image-1.tiff')\n    expect(incrementName('image-1.tiff')).toBe('image-2.tiff')\n  })\n\n  it('should preserve tif extension', () => {\n    expect(incrementName('image.tif')).toBe('image-1.tif')\n    expect(incrementName('image-1.tif')).toBe('image-2.tif')\n  })\n\n  it('should handle common image formats', () => {\n    expect(incrementName('image.png')).toBe('image-1.png')\n    expect(incrementName('image.gif')).toBe('image-1.gif')\n    expect(incrementName('image.webp')).toBe('image-1.webp')\n    expect(incrementName('image.avif')).toBe('image-1.avif')\n    expect(incrementName('image.svg')).toBe('image-1.svg')\n    expect(incrementName('image.bmp')).toBe('image-1.bmp')\n    expect(incrementName('image.ico')).toBe('image-1.ico')\n  })\n\n  it('should handle common document formats', () => {\n    expect(incrementName('document.pdf')).toBe('document-1.pdf')\n    expect(incrementName('document.doc')).toBe('document-1.doc')\n    expect(incrementName('document.docx')).toBe('document-1.docx')\n    expect(incrementName('spreadsheet.xls')).toBe('spreadsheet-1.xls')\n    expect(incrementName('spreadsheet.xlsx')).toBe('spreadsheet-1.xlsx')\n    expect(incrementName('presentation.ppt')).toBe('presentation-1.ppt')\n    expect(incrementName('presentation.pptx')).toBe('presentation-1.pptx')\n  })\n\n  it('should handle common video formats', () => {\n    expect(incrementName('video.mp4')).toBe('video-1.mp4')\n    expect(incrementName('video.mov')).toBe('video-1.mov')\n    expect(incrementName('video.avi')).toBe('video-1.avi')\n    expect(incrementName('video.webm')).toBe('video-1.webm')\n    expect(incrementName('video.mkv')).toBe('video-1.mkv')\n  })\n\n  it('should handle common audio formats', () => {\n    expect(incrementName('audio.mp3')).toBe('audio-1.mp3')\n    expect(incrementName('audio.wav')).toBe('audio-1.wav')\n    expect(incrementName('audio.ogg')).toBe('audio-1.ogg')\n    expect(incrementName('audio.flac')).toBe('audio-1.flac')\n    expect(incrementName('audio.aac')).toBe('audio-1.aac')\n  })\n\n  it('should handle uppercase extensions', () => {\n    expect(incrementName('PHOTO.JPG')).toBe('PHOTO-1.JPG')\n    expect(incrementName('PHOTO.JPEG')).toBe('PHOTO-1.JPEG')\n    expect(incrementName('IMAGE.PNG')).toBe('IMAGE-1.PNG')\n  })\n\n  it('should handle mixed case extensions', () => {\n    expect(incrementName('photo.Jpeg')).toBe('photo-1.Jpeg')\n    expect(incrementName('image.Png')).toBe('image-1.Png')\n  })\n})\n\ndescribe('getSafeFileName', () => {\n  const mockReq = {} as Parameters<typeof getSafeFileName>[0]['req']\n\n  beforeEach(() => {\n    vi.clearAllMocks()\n  })\n\n  it('should return original filename when no conflicts exist', async () => {\n    mockDocWithFilenameExists.mockResolvedValue(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpg',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('photo.jpg')\n    expect(mockDocWithFilenameExists).toHaveBeenCalledTimes(1)\n    expect(mockFileExists).toHaveBeenCalledTimes(1)\n  })\n\n  it('should increment filename when document exists in database', async () => {\n    mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpg',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('photo-1.jpg')\n  })\n\n  it('should increment filename when file exists on filesystem', async () => {\n    mockDocWithFilenameExists.mockResolvedValue(false)\n    mockFileExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpg',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('photo-1.jpg')\n  })\n\n  it('should keep incrementing until unique name is found', async () => {\n    mockDocWithFilenameExists\n      .mockResolvedValueOnce(true)\n      .mockResolvedValueOnce(true)\n      .mockResolvedValueOnce(true)\n      .mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpg',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('photo-3.jpg')\n  })\n\n  it('should handle conflicts from both database and filesystem', async () => {\n    mockDocWithFilenameExists\n      .mockResolvedValueOnce(true)\n      .mockResolvedValueOnce(false)\n      .mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpg',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('photo-2.jpg')\n  })\n\n  it('should pass prefix to docWithFilenameExists', async () => {\n    mockDocWithFilenameExists.mockResolvedValue(false)\n    mockFileExists.mockResolvedValue(false)\n\n    await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpg',\n      prefix: 'images/',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(mockDocWithFilenameExists).toHaveBeenCalledWith({\n      collectionSlug: 'media',\n      filename: 'photo.jpg',\n      path: '/uploads',\n      prefix: 'images/',\n      req: mockReq,\n    })\n  })\n\n  it('should check correct filesystem path', async () => {\n    mockDocWithFilenameExists.mockResolvedValue(false)\n    mockFileExists.mockResolvedValue(false)\n\n    await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpg',\n      req: mockReq,\n      staticPath: '/var/uploads/media',\n    })\n\n    expect(mockFileExists).toHaveBeenCalledWith('/var/uploads/media/photo.jpg')\n  })\n\n  it('should handle filename that already has numeric suffix', async () => {\n    mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo-5.jpg',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('photo-6.jpg')\n  })\n\n  it('should preserve jpeg extension when incrementing', async () => {\n    mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'photo.jpeg',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('photo-1.jpeg')\n  })\n\n  it('should preserve tiff extension when incrementing', async () => {\n    mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'image.tiff',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('image-1.tiff')\n  })\n\n  it('should handle webp files', async () => {\n    mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'image.webp',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('image-1.webp')\n  })\n\n  it('should handle pdf files', async () => {\n    mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'document.pdf',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('document-1.pdf')\n  })\n\n  it('should handle mp4 video files', async () => {\n    mockDocWithFilenameExists.mockResolvedValueOnce(true).mockResolvedValueOnce(false)\n    mockFileExists.mockResolvedValue(false)\n\n    const result = await getSafeFileName({\n      collectionSlug: 'media',\n      desiredFilename: 'video.mp4',\n      req: mockReq,\n      staticPath: '/uploads',\n    })\n\n    expect(result).toBe('video-1.mp4')\n  })\n})\n"],"names":["beforeEach","describe","expect","it","vi","getSafeFileName","incrementName","mock","docWithFilenameExists","fn","fileExists","mockDocWithFilenameExists","mocked","mockFileExists","toBe","mockReq","clearAllMocks","mockResolvedValue","result","collectionSlug","desiredFilename","req","staticPath","toHaveBeenCalledTimes","mockResolvedValueOnce","prefix","toHaveBeenCalledWith","filename","path"],"mappings":"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"}

package/dist/uploads/image-resizing/createImageSize.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Create the result object for the image resize operation based on the
+ * provided parameters. If the name is not provided, an empty result object
+ * is returned.
+ *
+ * @param filename - the filename of the image
+ * @param width - the width of the image
+ * @param height - the height of the image
+ * @param filesize - the filesize of the image
+ * @param mimeType - the mime type of the image
+ * @returns a FileSize result object
+ */
+import type { FileSize } from '../types.js';
+type CreateResultArgs = {
+    filename?: FileSize['filename'];
+    filesize?: FileSize['filesize'];
+    height?: FileSize['height'];
+    mimeType?: FileSize['mimeType'];
+    url?: FileSize['url'];
+    width?: FileSize['width'];
+};
+export declare const createImageSize: ({ filename, filesize, height, mimeType, url, width, }: CreateResultArgs) => FileSize;
+export {};
+//# sourceMappingURL=createImageSize.d.ts.map

package/dist/uploads/image-resizing/createImageSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createImageSize.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/createImageSize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAA;IAC/B,QAAQ,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC3B,QAAQ,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAA;IAC/B,GAAG,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAA;IACrB,KAAK,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAC1B,CAAA;AACD,eAAO,MAAM,eAAe,0DAOzB,gBAAgB,KAAG,QASrB,CAAA"}

package/dist/uploads/image-resizing/createImageSize.js

@@ -0,0 +1,23 @@
+/**
+ * Create the result object for the image resize operation based on the
+ * provided parameters. If the name is not provided, an empty result object
+ * is returned.
+ *
+ * @param filename - the filename of the image
+ * @param width - the width of the image
+ * @param height - the height of the image
+ * @param filesize - the filesize of the image
+ * @param mimeType - the mime type of the image
+ * @returns a FileSize result object
+ */ export const createImageSize = ({ filename = null, filesize = null, height = null, mimeType = null, url = null, width = null })=>{
+    return {
+        filename,
+        filesize,
+        height,
+        mimeType,
+        url,
+        width
+    };
+};
+
+//# sourceMappingURL=createImageSize.js.map

package/dist/uploads/image-resizing/createImageSize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/image-resizing/createImageSize.ts"],"sourcesContent":["/**\n * Create the result object for the image resize operation based on the\n * provided parameters. If the name is not provided, an empty result object\n * is returned.\n *\n * @param filename - the filename of the image\n * @param width - the width of the image\n * @param height - the height of the image\n * @param filesize - the filesize of the image\n * @param mimeType - the mime type of the image\n * @returns a FileSize result object\n */\n\nimport type { FileSize } from '../types.js'\n\ntype CreateResultArgs = {\n  filename?: FileSize['filename']\n  filesize?: FileSize['filesize']\n  height?: FileSize['height']\n  mimeType?: FileSize['mimeType']\n  url?: FileSize['url']\n  width?: FileSize['width']\n}\nexport const createImageSize = ({\n  filename = null,\n  filesize = null,\n  height = null,\n  mimeType = null,\n  url = null,\n  width = null,\n}: CreateResultArgs): FileSize => {\n  return {\n    filename,\n    filesize,\n    height,\n    mimeType,\n    url,\n    width,\n  }\n}\n"],"names":["createImageSize","filename","filesize","height","mimeType","url","width"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAYD,OAAO,MAAMA,kBAAkB,CAAC,EAC9BC,WAAW,IAAI,EACfC,WAAW,IAAI,EACfC,SAAS,IAAI,EACbC,WAAW,IAAI,EACfC,MAAM,IAAI,EACVC,QAAQ,IAAI,EACK;IACjB,OAAO;QACLL;QACAC;QACAC;QACAC;QACAC;QACAC;IACF;AACF,EAAC"}

package/dist/uploads/image-resizing/createImageSizes.d.ts

@@ -0,0 +1,39 @@
+import type { SanitizedCollectionConfig } from '../../collections/config/types.js';
+import type { SharpDependency } from '../../config/types.js';
+import type { PayloadRequest } from '../../types/index.js';
+import type { WithMetadata } from '../optionallyAppendMetadata.js';
+import type { FileSizes, FileToSave, FocalPoint, ProbedImageSize } from '../types.js';
+/**
+ * For the provided image sizes, handle the resizing and the transforms
+ * (format, trim, etc.) of each requested image size and return the result object.
+ * This only handles the image sizes. The transforms of the original image
+ * are handled in {@link ./generateFileData.ts}.
+ *
+ * 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 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)
+ */
+type ResizeArgs = {
+    config: SanitizedCollectionConfig;
+    dimensions: ProbedImageSize;
+    file: PayloadRequest['file'];
+    focalPoint?: FocalPoint;
+    mimeType: string;
+    req: PayloadRequest;
+    savedFilename: string;
+    sharp?: SharpDependency;
+    staticPath: string;
+    withMetadata?: WithMetadata;
+};
+/** Result from resizing and transforming the requested image sizes */
+type ImageSizesResult = {
+    sizeData: FileSizes;
+    sizesToSave: FileToSave[];
+};
+export declare function createImageSizes({ config, dimensions, file, focalPoint, mimeType, req, savedFilename, sharp, staticPath, withMetadata, }: ResizeArgs): Promise<ImageSizesResult>;
+export {};
+//# sourceMappingURL=createImageSizes.d.ts.map

package/dist/uploads/image-resizing/createImageSizes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createImageSizes.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/createImageSizes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAClE,OAAO,KAAK,EAAY,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAW/F;;;;;;;;;;;;;GAaG;AAEH,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,yBAAyB,CAAA;IACjC,UAAU,EAAE,eAAe,CAAA;IAC3B,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;IAC5B,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,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,YAAY,CAAC,EAAE,YAAY,CAAA;CAC5B,CAAA;AAED,sEAAsE;AACtE,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,SAAS,CAAA;IACnB,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B,CAAA;AAED,wBAAsB,gBAAgB,CAAC,EACrC,MAAM,EACN,UAAU,EACV,IAAI,EACJ,UAAU,EACV,QAAQ,EACR,GAAG,EACH,aAAa,EACb,KAAK,EACL,UAAU,EACV,YAAY,GACb,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAyOxC"}