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

package/dist/optionallyAppendMetadata.js

@@ -0,0 +1,17 @@
+export async function optionallyAppendMetadata({ req, sharpFile, withMetadata }) {
+    const metadata = await sharpFile.metadata();
+    if (withMetadata === true) {
+        return sharpFile.withMetadata();
+    } else if (typeof withMetadata === 'function') {
+        const useMetadata = await withMetadata({
+            metadata,
+            req
+        });
+        if (useMetadata) {
+            return sharpFile.withMetadata();
+        }
+    }
+    return sharpFile;
+}
+
+//# sourceMappingURL=optionallyAppendMetadata.js.map

package/dist/optionallyAppendMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/optionallyAppendMetadata.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\nimport type { Sharp } from 'sharp'\n\nimport type { WithMetadata } from './types.js'\n\nexport async function optionallyAppendMetadata({\n  req,\n  sharpFile,\n  withMetadata,\n}: {\n  req: PayloadRequest\n  sharpFile: Sharp\n  withMetadata: undefined | WithMetadata\n}): Promise<Sharp> {\n  const metadata = await sharpFile.metadata()\n\n  if (withMetadata === true) {\n    return sharpFile.withMetadata()\n  } else if (typeof withMetadata === 'function') {\n    const useMetadata = await withMetadata({ metadata, req })\n\n    if (useMetadata) {\n      return sharpFile.withMetadata()\n    }\n  }\n\n  return sharpFile\n}\n"],"names":["optionallyAppendMetadata","req","sharpFile","withMetadata","metadata","useMetadata"],"mappings":"AAKA,OAAO,eAAeA,yBAAyB,EAC7CC,GAAG,EACHC,SAAS,EACTC,YAAY,EAKb;IACC,MAAMC,WAAW,MAAMF,UAAUE,QAAQ;IAEzC,IAAID,iBAAiB,MAAM;QACzB,OAAOD,UAAUC,YAAY;IAC/B,OAAO,IAAI,OAAOA,iBAAiB,YAAY;QAC7C,MAAME,cAAc,MAAMF,aAAa;YAAEC;YAAUH;QAAI;QAEvD,IAAII,aAAa;YACf,OAAOH,UAAUC,YAAY;QAC/B;IACF;IAEA,OAAOD;AACT"}

package/dist/parseDynamicResize.d.ts

@@ -0,0 +1,17 @@
+import type { DynamicResizeParseResult } from './types.js';
+/**
+ * Strictly parses the v1 dynamic resize query parameters (`width`, `height`,
+ * `withoutEnlargement`). The presence of any of them routes the request —
+ * a malformed combination is `valid: false` (mapped to `400`), not treated as
+ * an ordinary read. Every other query key (`draft`, `depth`, `where`, `prefix`,
+ * …) is ignored.
+ */
+export declare function parseDynamicResize({ limits, searchParams, }: {
+    limits: {
+        maxHeight: number;
+        maxPixels: number;
+        maxWidth: number;
+    };
+    searchParams: URLSearchParams;
+}): DynamicResizeParseResult;
+//# sourceMappingURL=parseDynamicResize.d.ts.map

package/dist/parseDynamicResize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDynamicResize.d.ts","sourceRoot":"","sources":["../src/parseDynamicResize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAc1D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,MAAM,EACN,YAAY,GACb,EAAE;IACD,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAClE,YAAY,EAAE,eAAe,CAAA;CAC9B,GAAG,wBAAwB,CAiG3B"}

package/dist/parseDynamicResize.js

@@ -0,0 +1,117 @@
+const POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;
+function parsePositiveInteger(value) {
+    if (!POSITIVE_INTEGER_PATTERN.test(value)) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+/**
+ * Strictly parses the v1 dynamic resize query parameters (`width`, `height`,
+ * `withoutEnlargement`). The presence of any of them routes the request —
+ * a malformed combination is `valid: false` (mapped to `400`), not treated as
+ * an ordinary read. Every other query key (`draft`, `depth`, `where`, `prefix`,
+ * …) is ignored.
+ */ export function parseDynamicResize({ limits, searchParams }) {
+    const widthValues = searchParams.getAll('width');
+    const heightValues = searchParams.getAll('height');
+    const withoutEnlargementValues = searchParams.getAll('withoutEnlargement');
+    const isRouted = widthValues.length > 0 || heightValues.length > 0 || withoutEnlargementValues.length > 0;
+    if (!isRouted) {
+        return {
+            isRouted: false
+        };
+    }
+    if (widthValues.length > 1) {
+        return {
+            error: '`width` may only be specified once.',
+            isRouted: true,
+            valid: false
+        };
+    }
+    if (heightValues.length > 1) {
+        return {
+            error: '`height` may only be specified once.',
+            isRouted: true,
+            valid: false
+        };
+    }
+    if (withoutEnlargementValues.length > 1) {
+        return {
+            error: '`withoutEnlargement` may only be specified once.',
+            isRouted: true,
+            valid: false
+        };
+    }
+    if (widthValues.length === 0 && heightValues.length === 0) {
+        return {
+            error: 'At least one of `width` or `height` is required to resize.',
+            isRouted: true,
+            valid: false
+        };
+    }
+    let width;
+    if (widthValues.length === 1) {
+        width = parsePositiveInteger(widthValues[0]);
+        if (width === undefined) {
+            return {
+                error: '`width` must be a positive integer.',
+                isRouted: true,
+                valid: false
+            };
+        }
+        if (width > limits.maxWidth) {
+            return {
+                error: `\`width\` exceeds the configured maximum of ${limits.maxWidth}.`,
+                isRouted: true,
+                valid: false
+            };
+        }
+    }
+    let height;
+    if (heightValues.length === 1) {
+        height = parsePositiveInteger(heightValues[0]);
+        if (height === undefined) {
+            return {
+                error: '`height` must be a positive integer.',
+                isRouted: true,
+                valid: false
+            };
+        }
+        if (height > limits.maxHeight) {
+            return {
+                error: `\`height\` exceeds the configured maximum of ${limits.maxHeight}.`,
+                isRouted: true,
+                valid: false
+            };
+        }
+    }
+    if (width !== undefined && height !== undefined && width * height > limits.maxPixels) {
+        return {
+            error: `Requested dimensions exceed the configured maximum of ${limits.maxPixels} pixels.`,
+            isRouted: true,
+            valid: false
+        };
+    }
+    let withoutEnlargement;
+    if (withoutEnlargementValues.length === 1) {
+        const raw = withoutEnlargementValues[0];
+        if (raw !== 'true' && raw !== 'false') {
+            return {
+                error: '`withoutEnlargement` must be "true" or "false".',
+                isRouted: true,
+                valid: false
+            };
+        }
+        withoutEnlargement = raw === 'true';
+    }
+    return {
+        height,
+        isRouted: true,
+        valid: true,
+        width,
+        withoutEnlargement
+    };
+}
+
+//# sourceMappingURL=parseDynamicResize.js.map

package/dist/parseDynamicResize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parseDynamicResize.ts"],"sourcesContent":["import type { DynamicResizeParseResult } from './types.js'\n\nconst POSITIVE_INTEGER_PATTERN = /^[1-9]\\d*$/\n\nfunction parsePositiveInteger(value: string): number | undefined {\n  if (!POSITIVE_INTEGER_PATTERN.test(value)) {\n    return undefined\n  }\n\n  const parsed = Number(value)\n\n  return Number.isSafeInteger(parsed) ? parsed : undefined\n}\n\n/**\n * Strictly parses the v1 dynamic resize query parameters (`width`, `height`,\n * `withoutEnlargement`). The presence of any of them routes the request —\n * a malformed combination is `valid: false` (mapped to `400`), not treated as\n * an ordinary read. Every other query key (`draft`, `depth`, `where`, `prefix`,\n * …) is ignored.\n */\nexport function parseDynamicResize({\n  limits,\n  searchParams,\n}: {\n  limits: { maxHeight: number; maxPixels: number; maxWidth: number }\n  searchParams: URLSearchParams\n}): DynamicResizeParseResult {\n  const widthValues = searchParams.getAll('width')\n  const heightValues = searchParams.getAll('height')\n  const withoutEnlargementValues = searchParams.getAll('withoutEnlargement')\n\n  const isRouted =\n    widthValues.length > 0 || heightValues.length > 0 || withoutEnlargementValues.length > 0\n\n  if (!isRouted) {\n    return { isRouted: false }\n  }\n\n  if (widthValues.length > 1) {\n    return { error: '`width` may only be specified once.', isRouted: true, valid: false }\n  }\n\n  if (heightValues.length > 1) {\n    return { error: '`height` may only be specified once.', isRouted: true, valid: false }\n  }\n\n  if (withoutEnlargementValues.length > 1) {\n    return {\n      error: '`withoutEnlargement` may only be specified once.',\n      isRouted: true,\n      valid: false,\n    }\n  }\n\n  if (widthValues.length === 0 && heightValues.length === 0) {\n    return {\n      error: 'At least one of `width` or `height` is required to resize.',\n      isRouted: true,\n      valid: false,\n    }\n  }\n\n  let width: number | undefined\n\n  if (widthValues.length === 1) {\n    width = parsePositiveInteger(widthValues[0]!)\n\n    if (width === undefined) {\n      return { error: '`width` must be a positive integer.', isRouted: true, valid: false }\n    }\n\n    if (width > limits.maxWidth) {\n      return {\n        error: `\\`width\\` exceeds the configured maximum of ${limits.maxWidth}.`,\n        isRouted: true,\n        valid: false,\n      }\n    }\n  }\n\n  let height: number | undefined\n\n  if (heightValues.length === 1) {\n    height = parsePositiveInteger(heightValues[0]!)\n\n    if (height === undefined) {\n      return { error: '`height` must be a positive integer.', isRouted: true, valid: false }\n    }\n\n    if (height > limits.maxHeight) {\n      return {\n        error: `\\`height\\` exceeds the configured maximum of ${limits.maxHeight}.`,\n        isRouted: true,\n        valid: false,\n      }\n    }\n  }\n\n  if (width !== undefined && height !== undefined && width * height > limits.maxPixels) {\n    return {\n      error: `Requested dimensions exceed the configured maximum of ${limits.maxPixels} pixels.`,\n      isRouted: true,\n      valid: false,\n    }\n  }\n\n  let withoutEnlargement: boolean | undefined\n\n  if (withoutEnlargementValues.length === 1) {\n    const raw = withoutEnlargementValues[0]\n\n    if (raw !== 'true' && raw !== 'false') {\n      return {\n        error: '`withoutEnlargement` must be \"true\" or \"false\".',\n        isRouted: true,\n        valid: false,\n      }\n    }\n\n    withoutEnlargement = raw === 'true'\n  }\n\n  return { height, isRouted: true, valid: true, width, withoutEnlargement }\n}\n"],"names":["POSITIVE_INTEGER_PATTERN","parsePositiveInteger","value","test","undefined","parsed","Number","isSafeInteger","parseDynamicResize","limits","searchParams","widthValues","getAll","heightValues","withoutEnlargementValues","isRouted","length","error","valid","width","maxWidth","height","maxHeight","maxPixels","withoutEnlargement","raw"],"mappings":"AAEA,MAAMA,2BAA2B;AAEjC,SAASC,qBAAqBC,KAAa;IACzC,IAAI,CAACF,yBAAyBG,IAAI,CAACD,QAAQ;QACzC,OAAOE;IACT;IAEA,MAAMC,SAASC,OAAOJ;IAEtB,OAAOI,OAAOC,aAAa,CAACF,UAAUA,SAASD;AACjD;AAEA;;;;;;CAMC,GACD,OAAO,SAASI,mBAAmB,EACjCC,MAAM,EACNC,YAAY,EAIb;IACC,MAAMC,cAAcD,aAAaE,MAAM,CAAC;IACxC,MAAMC,eAAeH,aAAaE,MAAM,CAAC;IACzC,MAAME,2BAA2BJ,aAAaE,MAAM,CAAC;IAErD,MAAMG,WACJJ,YAAYK,MAAM,GAAG,KAAKH,aAAaG,MAAM,GAAG,KAAKF,yBAAyBE,MAAM,GAAG;IAEzF,IAAI,CAACD,UAAU;QACb,OAAO;YAAEA,UAAU;QAAM;IAC3B;IAEA,IAAIJ,YAAYK,MAAM,GAAG,GAAG;QAC1B,OAAO;YAAEC,OAAO;YAAuCF,UAAU;YAAMG,OAAO;QAAM;IACtF;IAEA,IAAIL,aAAaG,MAAM,GAAG,GAAG;QAC3B,OAAO;YAAEC,OAAO;YAAwCF,UAAU;YAAMG,OAAO;QAAM;IACvF;IAEA,IAAIJ,yBAAyBE,MAAM,GAAG,GAAG;QACvC,OAAO;YACLC,OAAO;YACPF,UAAU;YACVG,OAAO;QACT;IACF;IAEA,IAAIP,YAAYK,MAAM,KAAK,KAAKH,aAAaG,MAAM,KAAK,GAAG;QACzD,OAAO;YACLC,OAAO;YACPF,UAAU;YACVG,OAAO;QACT;IACF;IAEA,IAAIC;IAEJ,IAAIR,YAAYK,MAAM,KAAK,GAAG;QAC5BG,QAAQlB,qBAAqBU,WAAW,CAAC,EAAE;QAE3C,IAAIQ,UAAUf,WAAW;YACvB,OAAO;gBAAEa,OAAO;gBAAuCF,UAAU;gBAAMG,OAAO;YAAM;QACtF;QAEA,IAAIC,QAAQV,OAAOW,QAAQ,EAAE;YAC3B,OAAO;gBACLH,OAAO,CAAC,4CAA4C,EAAER,OAAOW,QAAQ,CAAC,CAAC,CAAC;gBACxEL,UAAU;gBACVG,OAAO;YACT;QACF;IACF;IAEA,IAAIG;IAEJ,IAAIR,aAAaG,MAAM,KAAK,GAAG;QAC7BK,SAASpB,qBAAqBY,YAAY,CAAC,EAAE;QAE7C,IAAIQ,WAAWjB,WAAW;YACxB,OAAO;gBAAEa,OAAO;gBAAwCF,UAAU;gBAAMG,OAAO;YAAM;QACvF;QAEA,IAAIG,SAASZ,OAAOa,SAAS,EAAE;YAC7B,OAAO;gBACLL,OAAO,CAAC,6CAA6C,EAAER,OAAOa,SAAS,CAAC,CAAC,CAAC;gBAC1EP,UAAU;gBACVG,OAAO;YACT;QACF;IACF;IAEA,IAAIC,UAAUf,aAAaiB,WAAWjB,aAAae,QAAQE,SAASZ,OAAOc,SAAS,EAAE;QACpF,OAAO;YACLN,OAAO,CAAC,sDAAsD,EAAER,OAAOc,SAAS,CAAC,QAAQ,CAAC;YAC1FR,UAAU;YACVG,OAAO;QACT;IACF;IAEA,IAAIM;IAEJ,IAAIV,yBAAyBE,MAAM,KAAK,GAAG;QACzC,MAAMS,MAAMX,wBAAwB,CAAC,EAAE;QAEvC,IAAIW,QAAQ,UAAUA,QAAQ,SAAS;YACrC,OAAO;gBACLR,OAAO;gBACPF,UAAU;gBACVG,OAAO;YACT;QACF;QAEAM,qBAAqBC,QAAQ;IAC/B;IAEA,OAAO;QAAEJ;QAAQN,UAAU;QAAMG,OAAO;QAAMC;QAAOK;IAAmB;AAC1E"}

package/dist/parseDynamicResize.spec.js

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest';
+import { parseDynamicResize } from './parseDynamicResize.js';
+const DEFAULT_LIMITS = {
+    maxHeight: 4096,
+    maxPixels: 16_777_216,
+    maxWidth: 4096
+};
+const parse = (query)=>parseDynamicResize({
+        limits: DEFAULT_LIMITS,
+        searchParams: new URLSearchParams(query)
+    });
+describe('parseDynamicResize', ()=>{
+    it('should route a request containing only withoutEnlargement, but reject it as invalid', ()=>{
+        const result = parse('withoutEnlargement=true');
+        expect(result.isRouted).toBe(true);
+        expect(result).toMatchObject({
+            valid: false
+        });
+    });
+    it.each([
+        true,
+        false
+    ])('should parse a valid withoutEnlargement=%s alongside width', (withoutEnlargement)=>{
+        expect(parse(`width=500&withoutEnlargement=${withoutEnlargement}`)).toEqual({
+            height: undefined,
+            isRouted: true,
+            valid: true,
+            width: 500,
+            withoutEnlargement
+        });
+    });
+    it('should reject an invalid withoutEnlargement value', ()=>{
+        const result = parse('width=500&withoutEnlargement=yes');
+        expect(result).toMatchObject({
+            isRouted: true,
+            valid: false
+        });
+    });
+    it.each([
+        'width=500&width=600',
+        'height=500&height=600',
+        'width=500&withoutEnlargement=true&withoutEnlargement=false'
+    ])('should reject a repeated parameter: %s', (query)=>{
+        expect(parse(query)).toMatchObject({
+            isRouted: true,
+            valid: false
+        });
+    });
+    it.each([
+        'abc',
+        '12.5',
+        '-5',
+        '0',
+        '',
+        '5px',
+        ' 5'
+    ])('should reject a non-positive-integer width: %s', (value)=>{
+        const result = parse(`width=${encodeURIComponent(value)}`);
+        expect(result).toMatchObject({
+            isRouted: true,
+            valid: false
+        });
+    });
+    it('should reject an unsafe-integer width without throwing', ()=>{
+        const result = parse('width=99999999999999999999999999999999');
+        expect(result).toMatchObject({
+            isRouted: true,
+            valid: false
+        });
+    });
+    it('should reject a width exceeding the configured maxWidth', ()=>{
+        const result = parse('width=5000');
+        expect(result).toMatchObject({
+            isRouted: true,
+            valid: false
+        });
+    });
+    it('should reject a height exceeding the configured maxHeight', ()=>{
+        const result = parse('height=5000');
+        expect(result).toMatchObject({
+            isRouted: true,
+            valid: false
+        });
+    });
+    it('should accept a width exactly at the configured maxWidth', ()=>{
+        expect(parse('width=4096')).toMatchObject({
+            isRouted: true,
+            valid: true
+        });
+    });
+    it('should reject a width/height combination whose product exceeds maxPixels even when each dimension is individually within its own limit', ()=>{
+        const result = parseDynamicResize({
+            limits: {
+                maxHeight: 4096,
+                maxPixels: 1000,
+                maxWidth: 4096
+            },
+            searchParams: new URLSearchParams('width=100&height=100')
+        });
+        expect(result).toMatchObject({
+            isRouted: true,
+            valid: false
+        });
+    });
+    it('should accept a width/height combination within the configured maxPixels', ()=>{
+        const result = parseDynamicResize({
+            limits: {
+                maxHeight: 4096,
+                maxPixels: 1000,
+                maxWidth: 4096
+            },
+            searchParams: new URLSearchParams('width=10&height=10')
+        });
+        expect(result).toMatchObject({
+            height: 10,
+            isRouted: true,
+            valid: true,
+            width: 10
+        });
+    });
+});
+
+//# sourceMappingURL=parseDynamicResize.spec.js.map

package/dist/parseDynamicResize.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parseDynamicResize.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { parseDynamicResize } from './parseDynamicResize.js'\n\nconst DEFAULT_LIMITS = { maxHeight: 4096, maxPixels: 16_777_216, maxWidth: 4096 }\n\nconst parse = (query: string) =>\n  parseDynamicResize({ limits: DEFAULT_LIMITS, searchParams: new URLSearchParams(query) })\n\ndescribe('parseDynamicResize', () => {\n  it('should route a request containing only withoutEnlargement, but reject it as invalid', () => {\n    const result = parse('withoutEnlargement=true')\n    expect(result.isRouted).toBe(true)\n    expect(result).toMatchObject({ valid: false })\n  })\n\n  it.each([true, false])(\n    'should parse a valid withoutEnlargement=%s alongside width',\n    (withoutEnlargement) => {\n      expect(parse(`width=500&withoutEnlargement=${withoutEnlargement}`)).toEqual({\n        height: undefined,\n        isRouted: true,\n        valid: true,\n        width: 500,\n        withoutEnlargement,\n      })\n    },\n  )\n\n  it('should reject an invalid withoutEnlargement value', () => {\n    const result = parse('width=500&withoutEnlargement=yes')\n    expect(result).toMatchObject({ isRouted: true, valid: false })\n  })\n\n  it.each([\n    'width=500&width=600',\n    'height=500&height=600',\n    'width=500&withoutEnlargement=true&withoutEnlargement=false',\n  ])('should reject a repeated parameter: %s', (query) => {\n    expect(parse(query)).toMatchObject({ isRouted: true, valid: false })\n  })\n\n  it.each(['abc', '12.5', '-5', '0', '', '5px', ' 5'])(\n    'should reject a non-positive-integer width: %s',\n    (value) => {\n      const result = parse(`width=${encodeURIComponent(value)}`)\n      expect(result).toMatchObject({ isRouted: true, valid: false })\n    },\n  )\n\n  it('should reject an unsafe-integer width without throwing', () => {\n    const result = parse('width=99999999999999999999999999999999')\n    expect(result).toMatchObject({ isRouted: true, valid: false })\n  })\n\n  it('should reject a width exceeding the configured maxWidth', () => {\n    const result = parse('width=5000')\n    expect(result).toMatchObject({ isRouted: true, valid: false })\n  })\n\n  it('should reject a height exceeding the configured maxHeight', () => {\n    const result = parse('height=5000')\n    expect(result).toMatchObject({ isRouted: true, valid: false })\n  })\n\n  it('should accept a width exactly at the configured maxWidth', () => {\n    expect(parse('width=4096')).toMatchObject({ isRouted: true, valid: true })\n  })\n\n  it('should reject a width/height combination whose product exceeds maxPixels even when each dimension is individually within its own limit', () => {\n    const result = parseDynamicResize({\n      limits: { maxHeight: 4096, maxPixels: 1000, maxWidth: 4096 },\n      searchParams: new URLSearchParams('width=100&height=100'),\n    })\n    expect(result).toMatchObject({ isRouted: true, valid: false })\n  })\n\n  it('should accept a width/height combination within the configured maxPixels', () => {\n    const result = parseDynamicResize({\n      limits: { maxHeight: 4096, maxPixels: 1000, maxWidth: 4096 },\n      searchParams: new URLSearchParams('width=10&height=10'),\n    })\n    expect(result).toMatchObject({ height: 10, isRouted: true, valid: true, width: 10 })\n  })\n})\n"],"names":["describe","expect","it","parseDynamicResize","DEFAULT_LIMITS","maxHeight","maxPixels","maxWidth","parse","query","limits","searchParams","URLSearchParams","result","isRouted","toBe","toMatchObject","valid","each","withoutEnlargement","toEqual","height","undefined","width","value","encodeURIComponent"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAE7C,SAASC,kBAAkB,QAAQ,0BAAyB;AAE5D,MAAMC,iBAAiB;IAAEC,WAAW;IAAMC,WAAW;IAAYC,UAAU;AAAK;AAEhF,MAAMC,QAAQ,CAACC,QACbN,mBAAmB;QAAEO,QAAQN;QAAgBO,cAAc,IAAIC,gBAAgBH;IAAO;AAExFT,SAAS,sBAAsB;IAC7BE,GAAG,uFAAuF;QACxF,MAAMW,SAASL,MAAM;QACrBP,OAAOY,OAAOC,QAAQ,EAAEC,IAAI,CAAC;QAC7Bd,OAAOY,QAAQG,aAAa,CAAC;YAAEC,OAAO;QAAM;IAC9C;IAEAf,GAAGgB,IAAI,CAAC;QAAC;QAAM;KAAM,EACnB,8DACA,CAACC;QACClB,OAAOO,MAAM,CAAC,6BAA6B,EAAEW,oBAAoB,GAAGC,OAAO,CAAC;YAC1EC,QAAQC;YACRR,UAAU;YACVG,OAAO;YACPM,OAAO;YACPJ;QACF;IACF;IAGFjB,GAAG,qDAAqD;QACtD,MAAMW,SAASL,MAAM;QACrBP,OAAOY,QAAQG,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAM;IAC9D;IAEAf,GAAGgB,IAAI,CAAC;QACN;QACA;QACA;KACD,EAAE,0CAA0C,CAACT;QAC5CR,OAAOO,MAAMC,QAAQO,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAM;IACpE;IAEAf,GAAGgB,IAAI,CAAC;QAAC;QAAO;QAAQ;QAAM;QAAK;QAAI;QAAO;KAAK,EACjD,kDACA,CAACM;QACC,MAAMX,SAASL,MAAM,CAAC,MAAM,EAAEiB,mBAAmBD,QAAQ;QACzDvB,OAAOY,QAAQG,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAM;IAC9D;IAGFf,GAAG,0DAA0D;QAC3D,MAAMW,SAASL,MAAM;QACrBP,OAAOY,QAAQG,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAM;IAC9D;IAEAf,GAAG,2DAA2D;QAC5D,MAAMW,SAASL,MAAM;QACrBP,OAAOY,QAAQG,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAM;IAC9D;IAEAf,GAAG,6DAA6D;QAC9D,MAAMW,SAASL,MAAM;QACrBP,OAAOY,QAAQG,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAM;IAC9D;IAEAf,GAAG,4DAA4D;QAC7DD,OAAOO,MAAM,eAAeQ,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAK;IAC1E;IAEAf,GAAG,0IAA0I;QAC3I,MAAMW,SAASV,mBAAmB;YAChCO,QAAQ;gBAAEL,WAAW;gBAAMC,WAAW;gBAAMC,UAAU;YAAK;YAC3DI,cAAc,IAAIC,gBAAgB;QACpC;QACAX,OAAOY,QAAQG,aAAa,CAAC;YAAEF,UAAU;YAAMG,OAAO;QAAM;IAC9D;IAEAf,GAAG,4EAA4E;QAC7E,MAAMW,SAASV,mBAAmB;YAChCO,QAAQ;gBAAEL,WAAW;gBAAMC,WAAW;gBAAMC,UAAU;YAAK;YAC3DI,cAAc,IAAIC,gBAAgB;QACpC;QACAX,OAAOY,QAAQG,aAAa,CAAC;YAAEK,QAAQ;YAAIP,UAAU;YAAMG,OAAO;YAAMM,OAAO;QAAG;IACpF;AACF"}

package/dist/prepareLegacyUpload.d.ts

@@ -0,0 +1,14 @@
+import type { UploadTransformerInternal } from 'payload/internal';
+import type { SharpCollectionConfig, SharpDependency } from './types.js';
+/**
+ * Computes the legacy upload tasks (the main file, optionally cropped, and every
+ * configured legacy image size) and hands each to the injected `transform` callback
+ * exactly once. Reads the Sharp-owned config from `sharpTransformer({ collections })`
+ * at factory-construction time — not from the sanitized collection, which only gets
+ * the narrowed projection `init()` writes back.
+ */
+export declare function createPrepareLegacyUpload({ collections, sharpDependency, }: {
+    collections: Partial<Record<string, SharpCollectionConfig>>;
+    sharpDependency: SharpDependency;
+}): NonNullable<UploadTransformerInternal['prepareUpload']>;
+//# sourceMappingURL=prepareLegacyUpload.d.ts.map

package/dist/prepareLegacyUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareLegacyUpload.d.ts","sourceRoot":"","sources":["../src/prepareLegacyUpload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAgC,yBAAyB,EAAE,MAAM,kBAAkB,CAAA;AAI/F,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAA0B,MAAM,YAAY,CAAA;AAsBhG;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,WAAW,EACX,eAAe,GAChB,EAAE;IACD,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAA;IAC3D,eAAe,EAAE,eAAe,CAAA;CACjC,GAAG,WAAW,CAAC,yBAAyB,CAAC,eAAe,CAAC,CAAC,CA6G1D"}

package/dist/prepareLegacyUpload.js

@@ -0,0 +1,147 @@
+import { isNumber } from 'payload/shared';
+import { canResizeImage } from './canResizeImage.js';
+import { createSharpFromFile } from './createSharpFromFile.js';
+import { getImageResizeAction } from './getImageResizeAction.js';
+import { mapWithBoundedConcurrency } from './mapWithBoundedConcurrency.js';
+import { sanitizeResizeConfig } from './sanitizeResizeConfig.js';
+/**
+ * Sharp throws on truncated/header-only files. Returns `undefined` instead —
+ * matching core's dependency-free probe — since unreadable dimensions shouldn't fail the upload.
+ */ async function tryProbe(file, sharpDependency) {
+    try {
+        const sharpFile = await createSharpFromFile({
+            file,
+            sharpDependency
+        });
+        const metadata = await sharpFile.metadata();
+        return metadata.width && metadata.height ? metadata : undefined;
+    } catch  {
+        return undefined;
+    }
+}
+/**
+ * Computes the legacy upload tasks (the main file, optionally cropped, and every
+ * configured legacy image size) and hands each to the injected `transform` callback
+ * exactly once. Reads the Sharp-owned config from `sharpTransformer({ collections })`
+ * at factory-construction time — not from the sanitized collection, which only gets
+ * the narrowed projection `init()` writes back.
+ */ export function createPrepareLegacyUpload({ collections, sharpDependency }) {
+    return async ({ collectionSlug, file, req, transform, uploadEdits })=>{
+        const collectionUpload = collections[collectionSlug] ?? {};
+        const fileSupportsResize = canResizeImage(file.type);
+        const cropData = uploadEdits && typeof uploadEdits === 'object' && 'crop' in uploadEdits ? uploadEdits.crop : undefined;
+        let originalDimensions;
+        if (fileSupportsResize) {
+            const originalMeta = await tryProbe(file, sharpDependency);
+            if (originalMeta) {
+                originalDimensions = {
+                    height: originalMeta.height,
+                    width: originalMeta.width
+                };
+            }
+        }
+        // Unreadable dimensions can't be cropped/resized — treat as non-resizable rather than failing the upload.
+        const canProcessAsImage = fileSupportsResize && originalDimensions !== undefined;
+        const crop = cropData && originalDimensions ? {
+            cropData,
+            heightInPixels: uploadEdits.heightInPixels,
+            originalDimensions,
+            widthInPixels: uploadEdits.widthInPixels
+        } : undefined;
+        const mainResultFile = await transform({
+            fieldPath: 'filename',
+            options: {
+                collectionUpload,
+                crop,
+                kind: 'main'
+            }
+        });
+        const mainResult = await describeResult({
+            fieldPath: 'filename',
+            fileSupportsResize: canProcessAsImage,
+            resultFile: mainResultFile,
+            sharpDependency
+        });
+        const results = [
+            mainResult
+        ];
+        // A cropped upload derives its sizes from the crop output, not the original.
+        const isCropped = Boolean(crop && mainResult.width && mainResult.height);
+        const sizeSourceFile = isCropped ? mainResultFile : undefined;
+        const sizeSourceDimensions = isCropped ? {
+            height: mainResult.height,
+            width: mainResult.width
+        } : originalDimensions;
+        // Same precedence `init()` applies: Sharp's setting, else the collection's own `focalPoint`.
+        const effectiveFocalPoint = collectionUpload.focalPoint ?? req.payload.collections[collectionSlug]?.config.upload?.focalPoint;
+        const focalPointEnabled = effectiveFocalPoint !== false;
+        const variants = collectionUpload.variants;
+        if (canProcessAsImage && Array.isArray(variants) && sizeSourceDimensions) {
+            const focalPoint = focalPointEnabled && uploadEdits?.focalPoint ? {
+                x: isNumber(uploadEdits.focalPoint.x) ? Math.round(uploadEdits.focalPoint.x) : 50,
+                y: isNumber(uploadEdits.focalPoint.y) ? Math.round(uploadEdits.focalPoint.y) : 50
+            } : undefined;
+            const sizeResults = await mapWithBoundedConcurrency(variants, async (rawConfig)=>{
+                const imageResizeConfig = sanitizeResizeConfig(rawConfig);
+                const fieldPath = `variants.${imageResizeConfig.name}`;
+                const resizeAction = getImageResizeAction({
+                    dimensions: sizeSourceDimensions,
+                    hasFocalPoint: Boolean(focalPoint),
+                    imageResizeConfig
+                });
+                if (resizeAction === 'omit') {
+                    return {
+                        fieldPath
+                    };
+                }
+                const sizeResultFile = await transform({
+                    fieldPath,
+                    file: sizeSourceFile,
+                    options: {
+                        collectionUpload,
+                        focalPoint: resizeAction === 'resizeWithFocalPoint' ? focalPoint : undefined,
+                        imageResizeConfig,
+                        kind: 'size',
+                        originalDimensions: sizeSourceDimensions
+                    }
+                });
+                return describeResult({
+                    fieldPath,
+                    fileSupportsResize: true,
+                    resultFile: sizeResultFile,
+                    sharpDependency
+                });
+            });
+            results.push(...sizeResults);
+        }
+        return results;
+    };
+}
+async function describeResult({ fieldPath, fileSupportsResize, resultFile, sharpDependency }) {
+    if (!fileSupportsResize) {
+        return {
+            fieldPath,
+            file: resultFile,
+            mimeType: resultFile.type
+        };
+    }
+    const meta = await tryProbe(resultFile, sharpDependency);
+    if (!meta) {
+        return {
+            fieldPath,
+            file: resultFile,
+            mimeType: resultFile.type
+        };
+    }
+    // `tryProbe` never sets `animated: true`, so `meta.height` is already the
+    // single-frame height — do not divide by page count here.
+    return {
+        fieldPath,
+        file: resultFile,
+        height: meta.height,
+        mimeType: resultFile.type,
+        width: meta.width
+    };
+}
+
+//# sourceMappingURL=prepareLegacyUpload.js.map

package/dist/prepareLegacyUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/prepareLegacyUpload.ts"],"sourcesContent":["import type { FocalPoint, ProbedImageSize } from 'payload'\nimport type { PreparedUploadTransformation, UploadTransformerInternal } from 'payload/internal'\n\nimport { isNumber } from 'payload/shared'\n\nimport type { SharpCollectionConfig, SharpDependency, SharpUploadTaskOptions } from './types.js'\n\nimport { canResizeImage } from './canResizeImage.js'\nimport { createSharpFromFile } from './createSharpFromFile.js'\nimport { getImageResizeAction } from './getImageResizeAction.js'\nimport { mapWithBoundedConcurrency } from './mapWithBoundedConcurrency.js'\nimport { sanitizeResizeConfig } from './sanitizeResizeConfig.js'\n\n/**\n * Sharp throws on truncated/header-only files. Returns `undefined` instead —\n * matching core's dependency-free probe — since unreadable dimensions shouldn't fail the upload.\n */\nasync function tryProbe(file: File, sharpDependency: SharpDependency) {\n  try {\n    const sharpFile = await createSharpFromFile({ file, sharpDependency })\n    const metadata = await sharpFile.metadata()\n    return metadata.width && metadata.height ? metadata : undefined\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Computes the legacy upload tasks (the main file, optionally cropped, and every\n * configured legacy image size) and hands each to the injected `transform` callback\n * exactly once. Reads the Sharp-owned config from `sharpTransformer({ collections })`\n * at factory-construction time — not from the sanitized collection, which only gets\n * the narrowed projection `init()` writes back.\n */\nexport function createPrepareLegacyUpload({\n  collections,\n  sharpDependency,\n}: {\n  collections: Partial<Record<string, SharpCollectionConfig>>\n  sharpDependency: SharpDependency\n}): NonNullable<UploadTransformerInternal['prepareUpload']> {\n  return async ({ collectionSlug, file, req, transform, uploadEdits }) => {\n    const collectionUpload = collections[collectionSlug] ?? {}\n\n    const fileSupportsResize = canResizeImage(file.type)\n\n    const cropData =\n      uploadEdits && typeof uploadEdits === 'object' && 'crop' in uploadEdits\n        ? uploadEdits.crop\n        : undefined\n\n    let originalDimensions: ProbedImageSize | undefined\n\n    if (fileSupportsResize) {\n      const originalMeta = await tryProbe(file, sharpDependency)\n      if (originalMeta) {\n        originalDimensions = { height: originalMeta.height, width: originalMeta.width }\n      }\n    }\n\n    // Unreadable dimensions can't be cropped/resized — treat as non-resizable rather than failing the upload.\n    const canProcessAsImage = fileSupportsResize && originalDimensions !== undefined\n\n    const crop =\n      cropData && originalDimensions\n        ? {\n            cropData,\n            heightInPixels: uploadEdits.heightInPixels!,\n            originalDimensions,\n            widthInPixels: uploadEdits.widthInPixels!,\n          }\n        : undefined\n\n    const mainResultFile = await transform({\n      fieldPath: 'filename',\n      options: { collectionUpload, crop, kind: 'main' } satisfies SharpUploadTaskOptions,\n    })\n\n    const mainResult = await describeResult({\n      fieldPath: 'filename',\n      fileSupportsResize: canProcessAsImage,\n      resultFile: mainResultFile,\n      sharpDependency,\n    })\n\n    const results: PreparedUploadTransformation[] = [mainResult]\n\n    // A cropped upload derives its sizes from the crop output, not the original.\n    const isCropped = Boolean(crop && mainResult.width && mainResult.height)\n    const sizeSourceFile = isCropped ? mainResultFile : undefined\n    const sizeSourceDimensions: ProbedImageSize | undefined = isCropped\n      ? { height: mainResult.height!, width: mainResult.width! }\n      : originalDimensions\n\n    // Same precedence `init()` applies: Sharp's setting, else the collection's own `focalPoint`.\n    const effectiveFocalPoint =\n      collectionUpload.focalPoint ??\n      req.payload.collections[collectionSlug]?.config.upload?.focalPoint\n    const focalPointEnabled = effectiveFocalPoint !== false\n    const variants = collectionUpload.variants\n\n    if (canProcessAsImage && Array.isArray(variants) && sizeSourceDimensions) {\n      const focalPoint: FocalPoint | undefined =\n        focalPointEnabled && uploadEdits?.focalPoint\n          ? {\n              x: isNumber(uploadEdits.focalPoint.x) ? Math.round(uploadEdits.focalPoint.x) : 50,\n              y: isNumber(uploadEdits.focalPoint.y) ? Math.round(uploadEdits.focalPoint.y) : 50,\n            }\n          : undefined\n\n      const sizeResults = await mapWithBoundedConcurrency(variants, async (rawConfig) => {\n        const imageResizeConfig = sanitizeResizeConfig(rawConfig)\n        const fieldPath = `variants.${imageResizeConfig.name}` as const\n\n        const resizeAction = getImageResizeAction({\n          dimensions: sizeSourceDimensions,\n          hasFocalPoint: Boolean(focalPoint),\n          imageResizeConfig,\n        })\n\n        if (resizeAction === 'omit') {\n          return { fieldPath } satisfies PreparedUploadTransformation\n        }\n\n        const sizeResultFile = await transform({\n          fieldPath,\n          file: sizeSourceFile,\n          options: {\n            collectionUpload,\n            focalPoint: resizeAction === 'resizeWithFocalPoint' ? focalPoint : undefined,\n            imageResizeConfig,\n            kind: 'size',\n            originalDimensions: sizeSourceDimensions,\n          } satisfies SharpUploadTaskOptions,\n        })\n\n        return describeResult({\n          fieldPath,\n          fileSupportsResize: true,\n          resultFile: sizeResultFile,\n          sharpDependency,\n        })\n      })\n\n      results.push(...sizeResults)\n    }\n\n    return results\n  }\n}\n\nasync function describeResult({\n  fieldPath,\n  fileSupportsResize,\n  resultFile,\n  sharpDependency,\n}: {\n  fieldPath: PreparedUploadTransformation['fieldPath']\n  fileSupportsResize: boolean\n  resultFile: File\n  sharpDependency: SharpDependency\n}): Promise<PreparedUploadTransformation> {\n  if (!fileSupportsResize) {\n    return { fieldPath, file: resultFile, mimeType: resultFile.type }\n  }\n\n  const meta = await tryProbe(resultFile, sharpDependency)\n\n  if (!meta) {\n    return { fieldPath, file: resultFile, mimeType: resultFile.type }\n  }\n\n  // `tryProbe` never sets `animated: true`, so `meta.height` is already the\n  // single-frame height — do not divide by page count here.\n  return {\n    fieldPath,\n    file: resultFile,\n    height: meta.height,\n    mimeType: resultFile.type,\n    width: meta.width,\n  }\n}\n"],"names":["isNumber","canResizeImage","createSharpFromFile","getImageResizeAction","mapWithBoundedConcurrency","sanitizeResizeConfig","tryProbe","file","sharpDependency","sharpFile","metadata","width","height","undefined","createPrepareLegacyUpload","collections","collectionSlug","req","transform","uploadEdits","collectionUpload","fileSupportsResize","type","cropData","crop","originalDimensions","originalMeta","canProcessAsImage","heightInPixels","widthInPixels","mainResultFile","fieldPath","options","kind","mainResult","describeResult","resultFile","results","isCropped","Boolean","sizeSourceFile","sizeSourceDimensions","effectiveFocalPoint","focalPoint","payload","config","upload","focalPointEnabled","variants","Array","isArray","x","Math","round","y","sizeResults","rawConfig","imageResizeConfig","name","resizeAction","dimensions","hasFocalPoint","sizeResultFile","push","mimeType","meta"],"mappings":"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"}

package/dist/prepareLegacyUpload.spec.js

@@ -0,0 +1,95 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createPrepareLegacyUpload } from './prepareLegacyUpload.js';
+const sharpDependency = ()=>({
+        metadata: async ()=>({
+                height: 1000,
+                width: 1000
+            })
+    });
+const makeReq = ({ focalPoint })=>({
+        payload: {
+            collections: {
+                media: {
+                    config: {
+                        upload: {
+                            focalPoint
+                        }
+                    }
+                }
+            }
+        }
+    });
+const runPrepareUpload = async ({ collectionFocalPoint, sharpConfig })=>{
+    const transform = vi.fn(async (_task)=>new File([
+            'x'
+        ], 'image.png', {
+            type: 'image/png'
+        }));
+    await createPrepareLegacyUpload({
+        collections: {
+            media: sharpConfig
+        },
+        sharpDependency
+    })({
+        collectionSlug: 'media',
+        file: new File([
+            'x'
+        ], 'image.png', {
+            type: 'image/png'
+        }),
+        req: makeReq({
+            focalPoint: collectionFocalPoint
+        }),
+        transform,
+        uploadEdits: {
+            focalPoint: {
+                x: 10,
+                y: 90
+            }
+        }
+    });
+    const sizeTask = transform.mock.calls.map(([task])=>task.options).find((options)=>options.kind === 'size');
+    return sizeTask?.kind === 'size' ? sizeTask.focalPoint : undefined;
+};
+const variants = [
+    {
+        name: 'card',
+        height: 200,
+        width: 400
+    }
+];
+describe('createPrepareLegacyUpload', ()=>{
+    it.each([
+        {
+            collectionFocalPoint: false,
+            expected: undefined,
+            sharpFocalPoint: undefined
+        },
+        {
+            collectionFocalPoint: false,
+            expected: {
+                x: 10,
+                y: 90
+            },
+            sharpFocalPoint: true
+        },
+        {
+            collectionFocalPoint: undefined,
+            expected: {
+                x: 10,
+                y: 90
+            },
+            sharpFocalPoint: undefined
+        }
+    ])('should resolve the size focal point from Sharp ($sharpFocalPoint) over the collection ($collectionFocalPoint)', async ({ collectionFocalPoint, expected, sharpFocalPoint })=>{
+        expect(await runPrepareUpload({
+            collectionFocalPoint,
+            sharpConfig: {
+                focalPoint: sharpFocalPoint,
+                variants
+            }
+        })).toEqual(expected);
+    });
+});
+
+//# sourceMappingURL=prepareLegacyUpload.spec.js.map

package/dist/prepareLegacyUpload.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/prepareLegacyUpload.spec.ts"],"sourcesContent":["import type { PayloadRequest, UploadEdits } from 'payload'\nimport type { UploadTransformTask } from 'payload/internal'\n\nimport { describe, expect, it, vi } from 'vitest'\n\nimport type { SharpCollectionConfig, SharpDependency, SharpUploadTaskOptions } from './types.js'\n\nimport { createPrepareLegacyUpload } from './prepareLegacyUpload.js'\n\nconst sharpDependency = (() => ({\n  metadata: async () => ({ height: 1000, width: 1000 }),\n})) as unknown as SharpDependency\n\nconst makeReq = ({ focalPoint }: { focalPoint?: boolean }): PayloadRequest =>\n  ({\n    payload: { collections: { media: { config: { upload: { focalPoint } } } } },\n  }) as unknown as PayloadRequest\n\nconst runPrepareUpload = async ({\n  collectionFocalPoint,\n  sharpConfig,\n}: {\n  collectionFocalPoint?: boolean\n  sharpConfig: SharpCollectionConfig\n}) => {\n  const transform = vi.fn(\n    async (_task: UploadTransformTask) => new File(['x'], 'image.png', { type: 'image/png' }),\n  )\n\n  await createPrepareLegacyUpload({ collections: { media: sharpConfig }, sharpDependency })({\n    collectionSlug: 'media',\n    file: new File(['x'], 'image.png', { type: 'image/png' }),\n    req: makeReq({ focalPoint: collectionFocalPoint }),\n    transform,\n    uploadEdits: { focalPoint: { x: 10, y: 90 } } as UploadEdits,\n  })\n\n  const sizeTask = transform.mock.calls\n    .map(([task]) => task.options as SharpUploadTaskOptions)\n    .find((options) => options.kind === 'size')\n\n  return sizeTask?.kind === 'size' ? sizeTask.focalPoint : undefined\n}\n\nconst variants = [{ name: 'card', height: 200, width: 400 }]\n\ndescribe('createPrepareLegacyUpload', () => {\n  it.each([\n    { collectionFocalPoint: false, expected: undefined, sharpFocalPoint: undefined },\n    { collectionFocalPoint: false, expected: { x: 10, y: 90 }, sharpFocalPoint: true },\n    { collectionFocalPoint: undefined, expected: { x: 10, y: 90 }, sharpFocalPoint: undefined },\n  ])(\n    'should resolve the size focal point from Sharp ($sharpFocalPoint) over the collection ($collectionFocalPoint)',\n    async ({ collectionFocalPoint, expected, sharpFocalPoint }) => {\n      expect(\n        await runPrepareUpload({\n          collectionFocalPoint,\n          sharpConfig: { focalPoint: sharpFocalPoint, variants },\n        }),\n      ).toEqual(expected)\n    },\n  )\n})\n"],"names":["describe","expect","it","vi","createPrepareLegacyUpload","sharpDependency","metadata","height","width","makeReq","focalPoint","payload","collections","media","config","upload","runPrepareUpload","collectionFocalPoint","sharpConfig","transform","fn","_task","File","type","collectionSlug","file","req","uploadEdits","x","y","sizeTask","mock","calls","map","task","options","find","kind","undefined","variants","name","each","expected","sharpFocalPoint","toEqual"],"mappings":"AAGA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,EAAEC,EAAE,QAAQ,SAAQ;AAIjD,SAASC,yBAAyB,QAAQ,2BAA0B;AAEpE,MAAMC,kBAAmB,IAAO,CAAA;QAC9BC,UAAU,UAAa,CAAA;gBAAEC,QAAQ;gBAAMC,OAAO;YAAK,CAAA;IACrD,CAAA;AAEA,MAAMC,UAAU,CAAC,EAAEC,UAAU,EAA4B,GACtD,CAAA;QACCC,SAAS;YAAEC,aAAa;gBAAEC,OAAO;oBAAEC,QAAQ;wBAAEC,QAAQ;4BAAEL;wBAAW;oBAAE;gBAAE;YAAE;QAAE;IAC5E,CAAA;AAEF,MAAMM,mBAAmB,OAAO,EAC9BC,oBAAoB,EACpBC,WAAW,EAIZ;IACC,MAAMC,YAAYhB,GAAGiB,EAAE,CACrB,OAAOC,QAA+B,IAAIC,KAAK;YAAC;SAAI,EAAE,aAAa;YAAEC,MAAM;QAAY;IAGzF,MAAMnB,0BAA0B;QAAEQ,aAAa;YAAEC,OAAOK;QAAY;QAAGb;IAAgB,GAAG;QACxFmB,gBAAgB;QAChBC,MAAM,IAAIH,KAAK;YAAC;SAAI,EAAE,aAAa;YAAEC,MAAM;QAAY;QACvDG,KAAKjB,QAAQ;YAAEC,YAAYO;QAAqB;QAChDE;QACAQ,aAAa;YAAEjB,YAAY;gBAAEkB,GAAG;gBAAIC,GAAG;YAAG;QAAE;IAC9C;IAEA,MAAMC,WAAWX,UAAUY,IAAI,CAACC,KAAK,CAClCC,GAAG,CAAC,CAAC,CAACC,KAAK,GAAKA,KAAKC,OAAO,EAC5BC,IAAI,CAAC,CAACD,UAAYA,QAAQE,IAAI,KAAK;IAEtC,OAAOP,UAAUO,SAAS,SAASP,SAASpB,UAAU,GAAG4B;AAC3D;AAEA,MAAMC,WAAW;IAAC;QAAEC,MAAM;QAAQjC,QAAQ;QAAKC,OAAO;IAAI;CAAE;AAE5DR,SAAS,6BAA6B;IACpCE,GAAGuC,IAAI,CAAC;QACN;YAAExB,sBAAsB;YAAOyB,UAAUJ;YAAWK,iBAAiBL;QAAU;QAC/E;YAAErB,sBAAsB;YAAOyB,UAAU;gBAAEd,GAAG;gBAAIC,GAAG;YAAG;YAAGc,iBAAiB;QAAK;QACjF;YAAE1B,sBAAsBqB;YAAWI,UAAU;gBAAEd,GAAG;gBAAIC,GAAG;YAAG;YAAGc,iBAAiBL;QAAU;KAC3F,EACC,iHACA,OAAO,EAAErB,oBAAoB,EAAEyB,QAAQ,EAAEC,eAAe,EAAE;QACxD1C,OACE,MAAMe,iBAAiB;YACrBC;YACAC,aAAa;gBAAER,YAAYiC;gBAAiBJ;YAAS;QACvD,IACAK,OAAO,CAACF;IACZ;AAEJ"}

package/dist/sanitizeResizeConfig.d.ts

@@ -0,0 +1,11 @@
+import type { ImageSize } from 'payload';
+/**
+ * Sanitize the resize config. If the resize config has the `withoutReduction`
+ * property set to true, the `fit` and `position` properties will be set to `contain`
+ * and `top left` respectively.
+ *
+ * @param resizeConfig - the resize config
+ * @returns a sanitized resize config
+ */
+export declare const sanitizeResizeConfig: (resizeConfig: ImageSize) => ImageSize;
+//# sourceMappingURL=sanitizeResizeConfig.d.ts.map

package/dist/sanitizeResizeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeResizeConfig.d.ts","sourceRoot":"","sources":["../src/sanitizeResizeConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,iBAAkB,SAAS,KAAG,SAU9D,CAAA"}

package/dist/sanitizeResizeConfig.js

@@ -0,0 +1,20 @@
+/**
+ * Sanitize the resize config. If the resize config has the `withoutReduction`
+ * property set to true, the `fit` and `position` properties will be set to `contain`
+ * and `top left` respectively.
+ *
+ * @param resizeConfig - the resize config
+ * @returns a sanitized resize config
+ */ export const sanitizeResizeConfig = (resizeConfig)=>{
+    if (resizeConfig.withoutReduction) {
+        return {
+            ...resizeConfig,
+            // Why fit `contain` should also be set to https://github.com/lovell/sharp/issues/3595
+            fit: resizeConfig?.fit || 'contain',
+            position: resizeConfig?.position || 'left top'
+        };
+    }
+    return resizeConfig;
+};
+
+//# sourceMappingURL=sanitizeResizeConfig.js.map

package/dist/sanitizeResizeConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sanitizeResizeConfig.ts"],"sourcesContent":["import type { ImageSize } from 'payload'\n\n/**\n * Sanitize the resize config. If the resize config has the `withoutReduction`\n * property set to true, the `fit` and `position` properties will be set to `contain`\n * and `top left` respectively.\n *\n * @param resizeConfig - the resize config\n * @returns a sanitized resize config\n */\nexport const sanitizeResizeConfig = (resizeConfig: ImageSize): ImageSize => {\n  if (resizeConfig.withoutReduction) {\n    return {\n      ...resizeConfig,\n      // Why fit `contain` should also be set to https://github.com/lovell/sharp/issues/3595\n      fit: resizeConfig?.fit || 'contain',\n      position: resizeConfig?.position || 'left top',\n    }\n  }\n  return resizeConfig\n}\n"],"names":["sanitizeResizeConfig","resizeConfig","withoutReduction","fit","position"],"mappings":"AAEA;;;;;;;CAOC,GACD,OAAO,MAAMA,uBAAuB,CAACC;IACnC,IAAIA,aAAaC,gBAAgB,EAAE;QACjC,OAAO;YACL,GAAGD,YAAY;YACf,sFAAsF;YACtFE,KAAKF,cAAcE,OAAO;YAC1BC,UAAUH,cAAcG,YAAY;QACtC;IACF;IACA,OAAOH;AACT,EAAC"}