@payloadcms/transformer-sharp 4.0.0-internal.58473b9

package/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2026 Payload CMS, LLC <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# Sharp Transformer for Payload
+
+Payload's official [file transformer](https://payloadcms.com/docs/upload/transformers) for Sharp-based image processing: upload-time resizing/format conversion (the same behavior Payload has always provided) plus opt-in request-time dynamic resizing.
+
+## Installation
+
+```sh
+pnpm add @payloadcms/transformer-sharp
+```
+
+## Usage
+
+Register `sharpTransformer()` under `upload.transformers` in your Payload Config:
+
+```ts
+import { buildConfig } from 'payload'
+import { sharpTransformer } from '@payloadcms/transformer-sharp'
+
+export default buildConfig({
+  upload: {
+    transformers: [sharpTransformer()],
+  },
+})
+```
+
+### Upload-time image processing
+
+Configure per-collection Sharp settings through `sharpTransformer({ collections })`:
+
+```ts
+sharpTransformer({
+  collections: {
+    media: {
+      variants: [
+        { name: 'thumbnail', width: 400, height: 300 },
+        { name: 'card', width: 768, height: 1024 },
+      ],
+      resizeOptions: { width: 2048, height: 2048, withoutEnlargement: true },
+      formatOptions: { format: 'webp' },
+      trimOptions: undefined,
+      constructorOptions: undefined,
+      withMetadata: false,
+      crop: true,
+      focalPoint: true,
+    },
+  },
+})
+```
+
+`variants`, `crop`, and `focalPoint` are also written back onto the collection's own sanitized `upload` config at startup (name/`admin`/`generateImageName` only, for `variants`), so the Admin Panel and generated types pick them up. Generated files are stored under each document's `variants` field.
+
+### Dynamic (request-time) resizing
+
+Dynamic resizing is **disabled by default** — resize query parameters are ignored and the original file is served. Enable it for every upload collection, or only the ones that need it:
+
+```ts
+sharpTransformer({ dynamic: true })
+sharpTransformer({ dynamic: { collections: ['media'] } })
+```
+
+Once enabled, requesting a stored image with recognized query parameters resizes it on the fly, without storing the result:
+
+```
+GET /api/media/file/photo.png?width=400
+GET /api/media/file/photo.png?width=400&height=300
+GET /api/media/file/photo.png?width=400&withoutEnlargement=true
+```
+
+Configure limits and defaults for these requests:
+
+```ts
+sharpTransformer({
+  dynamic: {
+    collections: ['media'], // omit to allow every upload collection
+    fit: 'cover', // default
+    position: 'center', // default
+    maxWidth: 4096, // default
+    maxHeight: 4096, // default
+    maxPixels: 16_777_216, // default
+    withoutEnlargement: false, // default
+  },
+})
+```
+
+Resized output is not cached, and anyone who can read a file can request it at any size within these limits. Before enabling dynamic resizing on a public collection, see [Securing dynamic resizing](https://payloadcms.com/docs/upload/transformers#securing-dynamic-resizing) for how to restrict it with access control, tighten the limits, and cache the output.
+
+### Injecting a custom Sharp build
+
+```ts
+import customSharp from 'sharp'
+
+sharpTransformer({ sharp: customSharp })
+```
+
+See the [File Transformers](https://payloadcms.com/docs/upload/transformers) docs for the full transformer contract, access-control lifecycle, and non-goals (no caching, no CDN integration, no jobs queue).
+
+## Migrating from Payload 3.x
+
+If you previously configured `sharp`/`resizeOptions`/`imageSizes`/etc. directly on your Payload Config or collections, run:
+
+```sh
+npx @payloadcms/codemod --transform migrate-sharp-to-transformer
+```
+
+See the [v4 migration guide](https://payloadcms.com/docs/migration-guide/v4#sharp-moved-out-of-core-into-payloadcmstransformer-sharp) for details.

package/dist/canResizeImage.d.ts

@@ -0,0 +1,2 @@
+export declare function canResizeImage(mimeType: string): boolean;
+//# sourceMappingURL=canResizeImage.d.ts.map

package/dist/canResizeImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canResizeImage.d.ts","sourceRoot":"","sources":["../src/canResizeImage.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAMxD"}

package/dist/canResizeImage.js

@@ -0,0 +1,12 @@
+export function canResizeImage(mimeType) {
+    return [
+        'image/jpeg',
+        'image/png',
+        'image/gif',
+        'image/webp',
+        'image/tiff',
+        'image/avif'
+    ].indexOf(mimeType) > -1;
+}
+
+//# sourceMappingURL=canResizeImage.js.map

package/dist/canResizeImage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/canResizeImage.ts"],"sourcesContent":["export function canResizeImage(mimeType: string): boolean {\n  return (\n    ['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/tiff', 'image/avif'].indexOf(\n      mimeType,\n    ) > -1\n  )\n}\n"],"names":["canResizeImage","mimeType","indexOf"],"mappings":"AAAA,OAAO,SAASA,eAAeC,QAAgB;IAC7C,OACE;QAAC;QAAc;QAAa;QAAa;QAAc;QAAc;KAAa,CAACC,OAAO,CACxFD,YACE,CAAC;AAET"}

package/dist/createSharpFromFile.d.ts

@@ -0,0 +1,8 @@
+import type { Sharp, SharpOptions } from 'sharp';
+import type { SharpDependency } from './types.js';
+export declare function createSharpFromFile({ file, options, sharpDependency, }: {
+    file: File;
+    options?: SharpOptions;
+    sharpDependency: SharpDependency;
+}): Promise<Sharp>;
+//# sourceMappingURL=createSharpFromFile.d.ts.map

package/dist/createSharpFromFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSharpFromFile.d.ts","sourceRoot":"","sources":["../src/createSharpFromFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAIhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AASjD,wBAAsB,mBAAmB,CAAC,EACxC,IAAI,EACJ,OAAO,EACP,eAAe,GAChB,EAAE;IACD,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,eAAe,EAAE,eAAe,CAAA;CACjC,GAAG,OAAO,CAAC,KAAK,CAAC,CASjB"}

package/dist/createSharpFromFile.js

@@ -0,0 +1,31 @@
+import { getUploadFilePath } from 'payload/internal';
+/**
+ * One upload can open the same in-memory source many times (metadata probes plus
+ * every variant, some concurrently). Sharing one buffer per File avoids a fresh
+ * full-size copy on each open.
+ */ const inMemorySourceBuffers = new WeakMap();
+export async function createSharpFromFile({ file, options, sharpDependency }) {
+    const filePath = getUploadFilePath(file);
+    if (filePath) {
+        return options && Object.keys(options).length > 0 ? sharpDependency(filePath, options) : sharpDependency(filePath);
+    }
+    return sharpDependency(await getInMemorySourceBuffer({
+        file
+    }), options);
+}
+function getInMemorySourceBuffer({ file }) {
+    const cachedBuffer = inMemorySourceBuffers.get(file);
+    if (cachedBuffer) {
+        return cachedBuffer;
+    }
+    const buffer = file.arrayBuffer().then((arrayBuffer)=>Buffer.from(arrayBuffer));
+    inMemorySourceBuffers.set(file, buffer);
+    buffer.catch(()=>{
+        if (inMemorySourceBuffers.get(file) === buffer) {
+            inMemorySourceBuffers.delete(file);
+        }
+    });
+    return buffer;
+}
+
+//# sourceMappingURL=createSharpFromFile.js.map

package/dist/createSharpFromFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createSharpFromFile.ts"],"sourcesContent":["import type { Sharp, SharpOptions } from 'sharp'\n\nimport { getUploadFilePath } from 'payload/internal'\n\nimport type { SharpDependency } from './types.js'\n\n/**\n * One upload can open the same in-memory source many times (metadata probes plus\n * every variant, some concurrently). Sharing one buffer per File avoids a fresh\n * full-size copy on each open.\n */\nconst inMemorySourceBuffers = new WeakMap<File, Promise<Buffer>>()\n\nexport async function createSharpFromFile({\n  file,\n  options,\n  sharpDependency,\n}: {\n  file: File\n  options?: SharpOptions\n  sharpDependency: SharpDependency\n}): Promise<Sharp> {\n  const filePath = getUploadFilePath(file)\n  if (filePath) {\n    return options && Object.keys(options).length > 0\n      ? sharpDependency(filePath, options)\n      : sharpDependency(filePath)\n  }\n\n  return sharpDependency(await getInMemorySourceBuffer({ file }), options)\n}\n\nfunction getInMemorySourceBuffer({ file }: { file: File }): Promise<Buffer> {\n  const cachedBuffer = inMemorySourceBuffers.get(file)\n  if (cachedBuffer) {\n    return cachedBuffer\n  }\n\n  const buffer = file.arrayBuffer().then((arrayBuffer) => Buffer.from(arrayBuffer))\n  inMemorySourceBuffers.set(file, buffer)\n  buffer.catch(() => {\n    if (inMemorySourceBuffers.get(file) === buffer) {\n      inMemorySourceBuffers.delete(file)\n    }\n  })\n\n  return buffer\n}\n"],"names":["getUploadFilePath","inMemorySourceBuffers","WeakMap","createSharpFromFile","file","options","sharpDependency","filePath","Object","keys","length","getInMemorySourceBuffer","cachedBuffer","get","buffer","arrayBuffer","then","Buffer","from","set","catch","delete"],"mappings":"AAEA,SAASA,iBAAiB,QAAQ,mBAAkB;AAIpD;;;;CAIC,GACD,MAAMC,wBAAwB,IAAIC;AAElC,OAAO,eAAeC,oBAAoB,EACxCC,IAAI,EACJC,OAAO,EACPC,eAAe,EAKhB;IACC,MAAMC,WAAWP,kBAAkBI;IACnC,IAAIG,UAAU;QACZ,OAAOF,WAAWG,OAAOC,IAAI,CAACJ,SAASK,MAAM,GAAG,IAC5CJ,gBAAgBC,UAAUF,WAC1BC,gBAAgBC;IACtB;IAEA,OAAOD,gBAAgB,MAAMK,wBAAwB;QAAEP;IAAK,IAAIC;AAClE;AAEA,SAASM,wBAAwB,EAAEP,IAAI,EAAkB;IACvD,MAAMQ,eAAeX,sBAAsBY,GAAG,CAACT;IAC/C,IAAIQ,cAAc;QAChB,OAAOA;IACT;IAEA,MAAME,SAASV,KAAKW,WAAW,GAAGC,IAAI,CAAC,CAACD,cAAgBE,OAAOC,IAAI,CAACH;IACpEd,sBAAsBkB,GAAG,CAACf,MAAMU;IAChCA,OAAOM,KAAK,CAAC;QACX,IAAInB,sBAAsBY,GAAG,CAACT,UAAUU,QAAQ;YAC9Cb,sBAAsBoB,MAAM,CAACjB;QAC/B;IACF;IAEA,OAAOU;AACT"}

package/dist/createSharpFromFile.spec.js

@@ -0,0 +1,120 @@
+import { setUploadFilePath } from 'payload/internal';
+import { describe, expect, it, vi } from 'vitest';
+import { createSharpFromFile } from './createSharpFromFile.js';
+describe('createSharpFromFile', ()=>{
+    it('passes a disk-backed File path directly to Sharp', async ()=>{
+        const file = new File([], 'photo.png', {
+            type: 'image/png'
+        });
+        const arrayBuffer = vi.spyOn(file, 'arrayBuffer');
+        const stream = vi.spyOn(file, 'stream');
+        const sharpFile = {};
+        const sharpDependency = vi.fn(()=>sharpFile);
+        setUploadFilePath(file, '/tmp/payload-upload.png');
+        await expect(createSharpFromFile({
+            file,
+            options: {
+                animated: true
+            },
+            sharpDependency
+        })).resolves.toBe(sharpFile);
+        expect(sharpDependency).toHaveBeenCalledWith('/tmp/payload-upload.png', {
+            animated: true
+        });
+        expect(arrayBuffer).not.toHaveBeenCalled();
+        expect(stream).not.toHaveBeenCalled();
+    });
+    it('should read an in-memory File once across concurrent calls', async ()=>{
+        const file = new File([
+            'image-bytes'
+        ], 'photo.png', {
+            type: 'image/png'
+        });
+        const arrayBuffer = vi.spyOn(file, 'arrayBuffer');
+        const sharpDependency = vi.fn(()=>({}));
+        await Promise.all(Array.from({
+            length: 4
+        }, ()=>createSharpFromFile({
+                file,
+                sharpDependency
+            })));
+        expect(arrayBuffer).toHaveBeenCalledTimes(1);
+        expect(sharpDependency).toHaveBeenCalledTimes(4);
+        const inputs = sharpDependency.mock.calls.map(([input])=>input);
+        expect(inputs.every((input)=>input === inputs[0])).toBe(true);
+    });
+    it('should read an in-memory File once across sequential calls', async ()=>{
+        const file = new File([
+            'image-bytes'
+        ], 'photo.png', {
+            type: 'image/png'
+        });
+        const arrayBuffer = vi.spyOn(file, 'arrayBuffer');
+        const sharpDependency = vi.fn(()=>({}));
+        await createSharpFromFile({
+            file,
+            sharpDependency
+        });
+        await createSharpFromFile({
+            file,
+            options: {
+                animated: true
+            },
+            sharpDependency
+        });
+        expect(arrayBuffer).toHaveBeenCalledTimes(1);
+        expect(sharpDependency.mock.calls[0][0]).toBe(sharpDependency.mock.calls[1][0]);
+        expect(sharpDependency.mock.calls[1][1]).toEqual({
+            animated: true
+        });
+    });
+    it('should cache different File objects separately', async ()=>{
+        const firstFile = new File([
+            'first'
+        ], 'first.png', {
+            type: 'image/png'
+        });
+        const secondFile = new File([
+            'second'
+        ], 'second.png', {
+            type: 'image/png'
+        });
+        const firstArrayBuffer = vi.spyOn(firstFile, 'arrayBuffer');
+        const secondArrayBuffer = vi.spyOn(secondFile, 'arrayBuffer');
+        const sharpDependency = vi.fn(()=>({}));
+        await createSharpFromFile({
+            file: firstFile,
+            sharpDependency
+        });
+        await createSharpFromFile({
+            file: secondFile,
+            sharpDependency
+        });
+        expect(firstArrayBuffer).toHaveBeenCalledTimes(1);
+        expect(secondArrayBuffer).toHaveBeenCalledTimes(1);
+        expect(String(sharpDependency.mock.calls[0][0])).toBe('first');
+        expect(String(sharpDependency.mock.calls[1][0])).toBe('second');
+    });
+    it('should retry reading a File after a rejected read', async ()=>{
+        const file = new File([
+            'image-bytes'
+        ], 'photo.png', {
+            type: 'image/png'
+        });
+        const readError = new Error('read failed');
+        const arrayBuffer = vi.spyOn(file, 'arrayBuffer').mockRejectedValueOnce(readError);
+        const sharpDependency = vi.fn(()=>({}));
+        await expect(createSharpFromFile({
+            file,
+            sharpDependency
+        })).rejects.toBe(readError);
+        await createSharpFromFile({
+            file,
+            sharpDependency
+        });
+        expect(arrayBuffer).toHaveBeenCalledTimes(2);
+        expect(String(sharpDependency.mock.calls[0][0])).toBe('image-bytes');
+    });
+});
+
+//# sourceMappingURL=createSharpFromFile.spec.js.map

package/dist/createSharpFromFile.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createSharpFromFile.spec.ts"],"sourcesContent":["import type { Sharp } from 'sharp'\n\nimport { setUploadFilePath } from 'payload/internal'\nimport { describe, expect, it, vi } from 'vitest'\n\nimport type { SharpDependency } from './types.js'\n\nimport { createSharpFromFile } from './createSharpFromFile.js'\n\ndescribe('createSharpFromFile', () => {\n  it('passes a disk-backed File path directly to Sharp', async () => {\n    const file = new File([], 'photo.png', { type: 'image/png' })\n    const arrayBuffer = vi.spyOn(file, 'arrayBuffer')\n    const stream = vi.spyOn(file, 'stream')\n    const sharpFile = {} as Sharp\n    const sharpDependency = vi.fn<SharpDependency>(() => sharpFile)\n    setUploadFilePath(file, '/tmp/payload-upload.png')\n\n    await expect(\n      createSharpFromFile({ file, options: { animated: true }, sharpDependency }),\n    ).resolves.toBe(sharpFile)\n    expect(sharpDependency).toHaveBeenCalledWith('/tmp/payload-upload.png', { animated: true })\n    expect(arrayBuffer).not.toHaveBeenCalled()\n    expect(stream).not.toHaveBeenCalled()\n  })\n\n  it('should read an in-memory File once across concurrent calls', async () => {\n    const file = new File(['image-bytes'], 'photo.png', { type: 'image/png' })\n    const arrayBuffer = vi.spyOn(file, 'arrayBuffer')\n    const sharpDependency = vi.fn<SharpDependency>(() => ({}) as Sharp)\n\n    await Promise.all(\n      Array.from({ length: 4 }, () => createSharpFromFile({ file, sharpDependency })),\n    )\n\n    expect(arrayBuffer).toHaveBeenCalledTimes(1)\n    expect(sharpDependency).toHaveBeenCalledTimes(4)\n\n    const inputs = sharpDependency.mock.calls.map(([input]) => input)\n\n    expect(inputs.every((input) => input === inputs[0])).toBe(true)\n  })\n\n  it('should read an in-memory File once across sequential calls', async () => {\n    const file = new File(['image-bytes'], 'photo.png', { type: 'image/png' })\n    const arrayBuffer = vi.spyOn(file, 'arrayBuffer')\n    const sharpDependency = vi.fn<SharpDependency>(() => ({}) as Sharp)\n\n    await createSharpFromFile({ file, sharpDependency })\n    await createSharpFromFile({ file, options: { animated: true }, sharpDependency })\n\n    expect(arrayBuffer).toHaveBeenCalledTimes(1)\n    expect(sharpDependency.mock.calls[0]![0]).toBe(sharpDependency.mock.calls[1]![0])\n    expect(sharpDependency.mock.calls[1]![1]).toEqual({ animated: true })\n  })\n\n  it('should cache different File objects separately', async () => {\n    const firstFile = new File(['first'], 'first.png', { type: 'image/png' })\n    const secondFile = new File(['second'], 'second.png', { type: 'image/png' })\n    const firstArrayBuffer = vi.spyOn(firstFile, 'arrayBuffer')\n    const secondArrayBuffer = vi.spyOn(secondFile, 'arrayBuffer')\n    const sharpDependency = vi.fn<SharpDependency>(() => ({}) as Sharp)\n\n    await createSharpFromFile({ file: firstFile, sharpDependency })\n    await createSharpFromFile({ file: secondFile, sharpDependency })\n\n    expect(firstArrayBuffer).toHaveBeenCalledTimes(1)\n    expect(secondArrayBuffer).toHaveBeenCalledTimes(1)\n    expect(String(sharpDependency.mock.calls[0]![0])).toBe('first')\n    expect(String(sharpDependency.mock.calls[1]![0])).toBe('second')\n  })\n\n  it('should retry reading a File after a rejected read', async () => {\n    const file = new File(['image-bytes'], 'photo.png', { type: 'image/png' })\n    const readError = new Error('read failed')\n    const arrayBuffer = vi.spyOn(file, 'arrayBuffer').mockRejectedValueOnce(readError)\n    const sharpDependency = vi.fn<SharpDependency>(() => ({}) as Sharp)\n\n    await expect(createSharpFromFile({ file, sharpDependency })).rejects.toBe(readError)\n    await createSharpFromFile({ file, sharpDependency })\n\n    expect(arrayBuffer).toHaveBeenCalledTimes(2)\n    expect(String(sharpDependency.mock.calls[0]![0])).toBe('image-bytes')\n  })\n})\n"],"names":["setUploadFilePath","describe","expect","it","vi","createSharpFromFile","file","File","type","arrayBuffer","spyOn","stream","sharpFile","sharpDependency","fn","options","animated","resolves","toBe","toHaveBeenCalledWith","not","toHaveBeenCalled","Promise","all","Array","from","length","toHaveBeenCalledTimes","inputs","mock","calls","map","input","every","toEqual","firstFile","secondFile","firstArrayBuffer","secondArrayBuffer","String","readError","Error","mockRejectedValueOnce","rejects"],"mappings":"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"}

package/dist/getImageResizeAction.d.ts

@@ -0,0 +1,24 @@
+import type { ImageSize, ProbedImageSize } from 'payload';
+/**
+ * Determine whether or not to resize the image.
+ * - resize using image config
+ * - resize using image config with focal adjustments
+ * - do not resize at all
+ *
+ * `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'
+ */
+export declare const getImageResizeAction: ({ dimensions: originalImage, hasFocalPoint, imageResizeConfig, }: {
+    dimensions: ProbedImageSize;
+    hasFocalPoint?: boolean;
+    imageResizeConfig: ImageSize;
+}) => 'omit' | 'resize' | 'resizeWithFocalPoint';
+//# sourceMappingURL=getImageResizeAction.d.ts.map

package/dist/getImageResizeAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getImageResizeAction.d.ts","sourceRoot":"","sources":["../src/getImageResizeAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAIzD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,qEAI9B;IACD,UAAU,EAAE,eAAe,CAAA;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,SAAS,CAAA;CAC7B,KAAG,MAAM,GAAG,QAAQ,GAAG,sBA8CvB,CAAA"}

package/dist/getImageResizeAction.js

@@ -0,0 +1,56 @@
+import { isNumber } from 'payload/shared';
+/**
+ * Determine whether or not to resize the image.
+ * - resize using image config
+ * - resize using image config with focal adjustments
+ * - do not resize at all
+ *
+ * `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'
+ */ export const getImageResizeAction = ({ dimensions: originalImage, hasFocalPoint, imageResizeConfig })=>{
+    const { fit, withoutEnlargement, withoutReduction } = imageResizeConfig;
+    const targetWidth = imageResizeConfig.width;
+    const targetHeight = imageResizeConfig.height;
+    // 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
+            ;
+        }
+    }
+    if (withoutEnlargement === undefined && (!targetWidth || !targetHeight)) {
+        if (targetWidth && originalImage.width < targetWidth || targetHeight && originalImage.height < targetHeight) {
+            return 'omit';
+        }
+    }
+    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';
+};
+
+//# sourceMappingURL=getImageResizeAction.js.map

package/dist/getImageResizeAction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/getImageResizeAction.ts"],"sourcesContent":["import type { ImageSize, ProbedImageSize } from 'payload'\n\nimport { isNumber } from 'payload/shared'\n\n/**\n * Determine whether or not to resize the image.\n * - resize using image config\n * - resize using image config with focal adjustments\n * - do not resize at all\n *\n * `imageResizeConfig.withoutEnlargement`:\n * - undefined [default]: uploading images with smaller width AND height than the image size will return null\n * - false: always enlarge images to the image size\n * - true: if the image is smaller than the image size, return the original image\n *\n * `imageResizeConfig.withoutReduction`:\n * - false [default]: always enlarge images to the image size\n * - true: if the image is smaller than the image size, return the original image\n *\n * @return 'omit' | 'resize' | 'resizeWithFocalPoint'\n */\nexport const getImageResizeAction = ({\n  dimensions: originalImage,\n  hasFocalPoint,\n  imageResizeConfig,\n}: {\n  dimensions: ProbedImageSize\n  hasFocalPoint?: boolean\n  imageResizeConfig: ImageSize\n}): 'omit' | 'resize' | 'resizeWithFocalPoint' => {\n  const { fit, withoutEnlargement, withoutReduction } = imageResizeConfig\n  const targetWidth = imageResizeConfig.width!\n  const targetHeight = imageResizeConfig.height!\n\n  // prevent upscaling by default when x and y are both smaller than target image size\n  if (targetHeight && targetWidth) {\n    const originalImageIsSmallerXAndY =\n      originalImage.width < targetWidth && originalImage.height < targetHeight\n    if (withoutEnlargement === undefined && originalImageIsSmallerXAndY) {\n      return 'omit' // prevent image size from being enlarged\n    }\n  }\n\n  if (withoutEnlargement === undefined && (!targetWidth || !targetHeight)) {\n    if (\n      (targetWidth && originalImage.width < targetWidth) ||\n      (targetHeight && originalImage.height < targetHeight)\n    ) {\n      return 'omit'\n    }\n  }\n\n  const originalImageIsSmallerXOrY =\n    originalImage.width < targetWidth || originalImage.height < targetHeight\n  if (fit === 'contain' || fit === 'inside') {\n    return 'resize'\n  }\n  if (!isNumber(targetHeight) && !isNumber(targetWidth)) {\n    return 'resize'\n  }\n\n  const targetAspectRatio = targetWidth / targetHeight\n  const originalAspectRatio = originalImage.width / originalImage.height\n  if (originalAspectRatio === targetAspectRatio) {\n    return 'resize'\n  }\n\n  if (withoutEnlargement && originalImageIsSmallerXOrY) {\n    return 'resize'\n  }\n  if (withoutReduction && !originalImageIsSmallerXOrY) {\n    return 'resize'\n  }\n\n  return hasFocalPoint ? 'resizeWithFocalPoint' : 'resize'\n}\n"],"names":["isNumber","getImageResizeAction","dimensions","originalImage","hasFocalPoint","imageResizeConfig","fit","withoutEnlargement","withoutReduction","targetWidth","width","targetHeight","height","originalImageIsSmallerXAndY","undefined","originalImageIsSmallerXOrY","targetAspectRatio","originalAspectRatio"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,iBAAgB;AAEzC;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMC,uBAAuB,CAAC,EACnCC,YAAYC,aAAa,EACzBC,aAAa,EACbC,iBAAiB,EAKlB;IACC,MAAM,EAAEC,GAAG,EAAEC,kBAAkB,EAAEC,gBAAgB,EAAE,GAAGH;IACtD,MAAMI,cAAcJ,kBAAkBK,KAAK;IAC3C,MAAMC,eAAeN,kBAAkBO,MAAM;IAE7C,oFAAoF;IACpF,IAAID,gBAAgBF,aAAa;QAC/B,MAAMI,8BACJV,cAAcO,KAAK,GAAGD,eAAeN,cAAcS,MAAM,GAAGD;QAC9D,IAAIJ,uBAAuBO,aAAaD,6BAA6B;YACnE,OAAO,OAAO,yCAAyC;;QACzD;IACF;IAEA,IAAIN,uBAAuBO,aAAc,CAAA,CAACL,eAAe,CAACE,YAAW,GAAI;QACvE,IACE,AAACF,eAAeN,cAAcO,KAAK,GAAGD,eACrCE,gBAAgBR,cAAcS,MAAM,GAAGD,cACxC;YACA,OAAO;QACT;IACF;IAEA,MAAMI,6BACJZ,cAAcO,KAAK,GAAGD,eAAeN,cAAcS,MAAM,GAAGD;IAC9D,IAAIL,QAAQ,aAAaA,QAAQ,UAAU;QACzC,OAAO;IACT;IACA,IAAI,CAACN,SAASW,iBAAiB,CAACX,SAASS,cAAc;QACrD,OAAO;IACT;IAEA,MAAMO,oBAAoBP,cAAcE;IACxC,MAAMM,sBAAsBd,cAAcO,KAAK,GAAGP,cAAcS,MAAM;IACtE,IAAIK,wBAAwBD,mBAAmB;QAC7C,OAAO;IACT;IAEA,IAAIT,sBAAsBQ,4BAA4B;QACpD,OAAO;IACT;IACA,IAAIP,oBAAoB,CAACO,4BAA4B;QACnD,OAAO;IACT;IAEA,OAAOX,gBAAgB,yBAAyB;AAClD,EAAC"}

package/dist/handleRequest.d.ts

@@ -0,0 +1,14 @@
+import type { HandleTransformRequestArgs, HandleTransformRequestResult } from 'payload';
+import type { SharpDependency, SharpDynamicDefaults } from './types.js';
+/**
+ * Builds the request-time `handleRequest` stage: parses and validates the v1
+ * dynamic parameters (`width`, `height`, `withoutEnlargement`), retrieves the
+ * source exactly once — only after validation passes — and resizes it while
+ * preserving the source format. Unexpected Sharp errors are left to propagate
+ * uncaught; Payload's orchestrator logs and aborts the pipeline.
+ */
+export declare function createHandleRequest({ dynamicDefaults, sharpDependency, }: {
+    dynamicDefaults: Required<SharpDynamicDefaults>;
+    sharpDependency: SharpDependency;
+}): (args: HandleTransformRequestArgs) => Promise<HandleTransformRequestResult>;
+//# sourceMappingURL=handleRequest.d.ts.map

package/dist/handleRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleRequest.d.ts","sourceRoot":"","sources":["../src/handleRequest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAA;AAGvF,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAOvE;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,eAAe,EACf,eAAe,GAChB,EAAE;IACD,eAAe,EAAE,QAAQ,CAAC,oBAAoB,CAAC,CAAA;IAC/C,eAAe,EAAE,eAAe,CAAA;CACjC,GAAG,CAAC,IAAI,EAAE,0BAA0B,KAAK,OAAO,CAAC,4BAA4B,CAAC,CA2G9E"}

package/dist/handleRequest.js

@@ -0,0 +1,143 @@
+import { parseDynamicResize } from './parseDynamicResize.js';
+// Must match generateFileData.ts's allow-list — the only MIME types Sharp auto-detects multi-frame animation for.
+const ANIMATED_MIME_TYPES = [
+    'image/avif',
+    'image/gif',
+    'image/webp'
+];
+/**
+ * Builds the request-time `handleRequest` stage: parses and validates the v1
+ * dynamic parameters (`width`, `height`, `withoutEnlargement`), retrieves the
+ * source exactly once — only after validation passes — and resizes it while
+ * preserving the source format. Unexpected Sharp errors are left to propagate
+ * uncaught; Payload's orchestrator logs and aborts the pipeline.
+ */ export function createHandleRequest({ dynamicDefaults, sharpDependency }) {
+    return async ({ getSourceFile, mimeType, req })=>{
+        const parseResult = parseDynamicResize({
+            limits: dynamicDefaults,
+            searchParams: req.searchParams ?? new URLSearchParams()
+        });
+        if (!parseResult.isRouted) {
+            return {
+                status: 'continue'
+            };
+        }
+        if (!parseResult.valid) {
+            return {
+                response: Response.json({
+                    errors: [
+                        {
+                            message: parseResult.error
+                        }
+                    ]
+                }, {
+                    status: 400
+                }),
+                status: 'complete'
+            };
+        }
+        if (req.headers?.get('range')) {
+            return {
+                response: new Response(null, {
+                    status: 416
+                }),
+                status: 'complete'
+            };
+        }
+        const source = await getSourceFile();
+        if (!source.ok) {
+            return {
+                response: source,
+                status: 'complete'
+            };
+        }
+        const sourceBuffer = Buffer.from(await source.arrayBuffer());
+        const isAnimated = ANIMATED_MIME_TYPES.includes(mimeType);
+        const sharpOptions = isAnimated ? {
+            animated: true
+        } : {};
+        const withoutEnlargement = parseResult.withoutEnlargement ?? dynamicDefaults.withoutEnlargement;
+        // The output size is only known once the source is probed: with a single dimension
+        // Sharp derives the other from the aspect ratio, `fit: 'outside'` can overflow the
+        // requested box along one axis, and an animated source is resized frame by frame,
+        // so its real cost is the per-frame output times the frame count.
+        if (isAnimated || parseResult.width === undefined || parseResult.height === undefined || dynamicDefaults.fit === 'outside') {
+            const metadata = await sharpDependency(sourceBuffer, sharpOptions).metadata();
+            const frameCount = isAnimated ? metadata.pages ?? 1 : 1;
+            const frameHeight = metadata.pageHeight ?? metadata.height;
+            // EXIF orientations 5-8 rotate the image by 90°, so `.rotate()` below swaps its axes.
+            const isRotatedQuarterTurn = [
+                5,
+                6,
+                7,
+                8
+            ].includes(metadata.orientation);
+            const output = getOutputDimensions({
+                fit: dynamicDefaults.fit,
+                height: parseResult.height,
+                sourceHeight: isRotatedQuarterTurn ? metadata.width : frameHeight,
+                sourceWidth: isRotatedQuarterTurn ? frameHeight : metadata.width,
+                width: parseResult.width,
+                withoutEnlargement
+            });
+            if (output && (output.width > dynamicDefaults.maxWidth || output.height > dynamicDefaults.maxHeight || output.width * output.height * frameCount > dynamicDefaults.maxPixels)) {
+                const frameDescription = frameCount > 1 ? ` across ${frameCount} frames` : '';
+                return {
+                    response: Response.json({
+                        errors: [
+                            {
+                                message: `Requested dimensions (${output.width}x${output.height}${frameDescription}) exceed the configured maximum.`
+                            }
+                        ]
+                    }, {
+                        status: 400
+                    }),
+                    status: 'complete'
+                };
+            }
+        }
+        // Sharp drops the EXIF orientation tag on output, so apply it to the pixels first.
+        const resizedBuffer = await sharpDependency(sourceBuffer, sharpOptions).rotate().resize({
+            fit: dynamicDefaults.fit,
+            height: parseResult.height,
+            position: dynamicDefaults.position,
+            width: parseResult.width,
+            withoutEnlargement
+        }).toBuffer();
+        const headers = new Headers();
+        headers.set('Content-Type', mimeType);
+        headers.set('Content-Length', String(resizedBuffer.length));
+        return {
+            response: new Response(req.method === 'HEAD' ? null : resizedBuffer, {
+                headers,
+                status: 200
+            }),
+            status: 'continue'
+        };
+    };
+}
+/**
+ * The per-frame output size. When both dimensions are requested with any `fit` other
+ * than `'outside'` this is the requested box, an upper bound (`fit: 'contain'`/`'inside'`
+ * or `withoutEnlargement` can render smaller), which is what a resource budget needs.
+ * `'outside'` scales to cover the box, so one axis can exceed it.
+ */ function getOutputDimensions({ fit, height, sourceHeight, sourceWidth, width, withoutEnlargement }) {
+    const hasBothDimensions = width !== undefined && height !== undefined;
+    if (hasBothDimensions && fit !== 'outside') {
+        return {
+            height,
+            width
+        };
+    }
+    if (!sourceWidth || !sourceHeight) {
+        return undefined;
+    }
+    const scale = hasBothDimensions ? Math.max(width / sourceWidth, height / sourceHeight) : width !== undefined ? width / sourceWidth : height / sourceHeight;
+    const effectiveScale = withoutEnlargement ? Math.min(scale, 1) : scale;
+    return {
+        height: Math.round(sourceHeight * effectiveScale),
+        width: Math.round(sourceWidth * effectiveScale)
+    };
+}
+
+//# sourceMappingURL=handleRequest.js.map

package/dist/handleRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/handleRequest.ts"],"sourcesContent":["import type { HandleTransformRequestArgs, HandleTransformRequestResult } from 'payload'\nimport type { SharpOptions } from 'sharp'\n\nimport type { SharpDependency, SharpDynamicDefaults } from './types.js'\n\nimport { parseDynamicResize } from './parseDynamicResize.js'\n\n// Must match generateFileData.ts's allow-list — the only MIME types Sharp auto-detects multi-frame animation for.\nconst ANIMATED_MIME_TYPES = ['image/avif', 'image/gif', 'image/webp']\n\n/**\n * Builds the request-time `handleRequest` stage: parses and validates the v1\n * dynamic parameters (`width`, `height`, `withoutEnlargement`), retrieves the\n * source exactly once — only after validation passes — and resizes it while\n * preserving the source format. Unexpected Sharp errors are left to propagate\n * uncaught; Payload's orchestrator logs and aborts the pipeline.\n */\nexport function createHandleRequest({\n  dynamicDefaults,\n  sharpDependency,\n}: {\n  dynamicDefaults: Required<SharpDynamicDefaults>\n  sharpDependency: SharpDependency\n}): (args: HandleTransformRequestArgs) => Promise<HandleTransformRequestResult> {\n  return async ({ getSourceFile, mimeType, req }) => {\n    const parseResult = parseDynamicResize({\n      limits: dynamicDefaults,\n      searchParams: req.searchParams ?? new URLSearchParams(),\n    })\n\n    if (!parseResult.isRouted) {\n      return { status: 'continue' }\n    }\n\n    if (!parseResult.valid) {\n      return {\n        response: Response.json({ errors: [{ message: parseResult.error }] }, { status: 400 }),\n        status: 'complete',\n      }\n    }\n\n    if (req.headers?.get('range')) {\n      return { response: new Response(null, { status: 416 }), status: 'complete' }\n    }\n\n    const source = await getSourceFile()\n\n    if (!source.ok) {\n      return { response: source, status: 'complete' }\n    }\n\n    const sourceBuffer = Buffer.from(await source.arrayBuffer())\n\n    const isAnimated = ANIMATED_MIME_TYPES.includes(mimeType)\n    const sharpOptions: SharpOptions = isAnimated ? { animated: true } : {}\n\n    const withoutEnlargement = parseResult.withoutEnlargement ?? dynamicDefaults.withoutEnlargement\n\n    // The output size is only known once the source is probed: with a single dimension\n    // Sharp derives the other from the aspect ratio, `fit: 'outside'` can overflow the\n    // requested box along one axis, and an animated source is resized frame by frame,\n    // so its real cost is the per-frame output times the frame count.\n    if (\n      isAnimated ||\n      parseResult.width === undefined ||\n      parseResult.height === undefined ||\n      dynamicDefaults.fit === 'outside'\n    ) {\n      const metadata = await sharpDependency(sourceBuffer, sharpOptions).metadata()\n      const frameCount = isAnimated ? (metadata.pages ?? 1) : 1\n      const frameHeight = metadata.pageHeight ?? metadata.height\n      // EXIF orientations 5-8 rotate the image by 90°, so `.rotate()` below swaps its axes.\n      const isRotatedQuarterTurn = [5, 6, 7, 8].includes(metadata.orientation!)\n      const output = getOutputDimensions({\n        fit: dynamicDefaults.fit,\n        height: parseResult.height,\n        sourceHeight: isRotatedQuarterTurn ? metadata.width : frameHeight,\n        sourceWidth: isRotatedQuarterTurn ? frameHeight : metadata.width,\n        width: parseResult.width,\n        withoutEnlargement,\n      })\n\n      if (\n        output &&\n        (output.width > dynamicDefaults.maxWidth ||\n          output.height > dynamicDefaults.maxHeight ||\n          output.width * output.height * frameCount > dynamicDefaults.maxPixels)\n      ) {\n        const frameDescription = frameCount > 1 ? ` across ${frameCount} frames` : ''\n\n        return {\n          response: Response.json(\n            {\n              errors: [\n                {\n                  message: `Requested dimensions (${output.width}x${output.height}${frameDescription}) exceed the configured maximum.`,\n                },\n              ],\n            },\n            { status: 400 },\n          ),\n          status: 'complete',\n        }\n      }\n    }\n\n    // Sharp drops the EXIF orientation tag on output, so apply it to the pixels first.\n    const resizedBuffer = await sharpDependency(sourceBuffer, sharpOptions)\n      .rotate()\n      .resize({\n        fit: dynamicDefaults.fit,\n        height: parseResult.height,\n        position: dynamicDefaults.position,\n        width: parseResult.width,\n        withoutEnlargement,\n      })\n      .toBuffer()\n\n    const headers = new Headers()\n    headers.set('Content-Type', mimeType)\n    headers.set('Content-Length', String(resizedBuffer.length))\n\n    return {\n      response: new Response(req.method === 'HEAD' ? null : resizedBuffer, {\n        headers,\n        status: 200,\n      }),\n      status: 'continue',\n    }\n  }\n}\n\n/**\n * The per-frame output size. When both dimensions are requested with any `fit` other\n * than `'outside'` this is the requested box, an upper bound (`fit: 'contain'`/`'inside'`\n * or `withoutEnlargement` can render smaller), which is what a resource budget needs.\n * `'outside'` scales to cover the box, so one axis can exceed it.\n */\nfunction getOutputDimensions({\n  fit,\n  height,\n  sourceHeight,\n  sourceWidth,\n  width,\n  withoutEnlargement,\n}: {\n  fit: SharpDynamicDefaults['fit']\n  height: number | undefined\n  sourceHeight: number | undefined\n  sourceWidth: number | undefined\n  width: number | undefined\n  withoutEnlargement: boolean\n}): { height: number; width: number } | undefined {\n  const hasBothDimensions = width !== undefined && height !== undefined\n\n  if (hasBothDimensions && fit !== 'outside') {\n    return { height, width }\n  }\n\n  if (!sourceWidth || !sourceHeight) {\n    return undefined\n  }\n\n  const scale = hasBothDimensions\n    ? Math.max(width / sourceWidth, height / sourceHeight)\n    : width !== undefined\n      ? width / sourceWidth\n      : height! / sourceHeight\n  const effectiveScale = withoutEnlargement ? Math.min(scale, 1) : scale\n\n  return {\n    height: Math.round(sourceHeight * effectiveScale),\n    width: Math.round(sourceWidth * effectiveScale),\n  }\n}\n"],"names":["parseDynamicResize","ANIMATED_MIME_TYPES","createHandleRequest","dynamicDefaults","sharpDependency","getSourceFile","mimeType","req","parseResult","limits","searchParams","URLSearchParams","isRouted","status","valid","response","Response","json","errors","message","error","headers","get","source","ok","sourceBuffer","Buffer","from","arrayBuffer","isAnimated","includes","sharpOptions","animated","withoutEnlargement","width","undefined","height","fit","metadata","frameCount","pages","frameHeight","pageHeight","isRotatedQuarterTurn","orientation","output","getOutputDimensions","sourceHeight","sourceWidth","maxWidth","maxHeight","maxPixels","frameDescription","resizedBuffer","rotate","resize","position","toBuffer","Headers","set","String","length","method","hasBothDimensions","scale","Math","max","effectiveScale","min","round"],"mappings":"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"}