payload 4.0.0-internal.4cbdd50 → 4.0.0-internal.4e1f822

package/dist/uploads/image-resizing/createImageSizes.spec.js

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createImageSizes } from './createImageSizes.js';
+const createSharpMock = ()=>{
+    const chain = {
+        metadata: vi.fn().mockResolvedValue({
+            height: 10,
+            orientation: 1,
+            width: 10
+        }),
+        rotate: vi.fn(()=>chain)
+    };
+    const sharp = vi.fn(()=>chain);
+    return sharp;
+};
+const createFile = (mimetype)=>({
+        data: Buffer.from('original'),
+        mimetype,
+        name: 'photo',
+        size: 8
+    });
+// Larger than the source image, with `withoutEnlargement` left undefined, so
+// `getImageResizeAction` returns `'omit'` before any resize/extract sharp calls run - the initial
+// `sharp(...)` call used to probe the source image's own metadata is all that's under test here.
+const config = {
+    upload: {
+        imageSizes: [
+            {
+                name: 'thumb',
+                height: 100,
+                width: 100
+            }
+        ]
+    }
+};
+describe('createImageSizes', ()=>{
+    it('enables sharp animated reading for tiff, matching isAnimatedImage', async ()=>{
+        const sharp = createSharpMock();
+        const file = createFile('image/tiff');
+        await createImageSizes({
+            config,
+            dimensions: {
+                height: 10,
+                width: 10
+            },
+            file,
+            mimeType: 'image/tiff',
+            req: {
+                payloadUploadSizes: {}
+            },
+            savedFilename: 'photo.tiff',
+            sharp: sharp,
+            staticPath: '/tmp'
+        });
+        expect(sharp).toHaveBeenCalledWith(file.data, {
+            animated: true
+        });
+    });
+    it('does not enable sharp animated reading for avif, matching isAnimatedImage', async ()=>{
+        const sharp = createSharpMock();
+        const file = createFile('image/avif');
+        await createImageSizes({
+            config,
+            dimensions: {
+                height: 10,
+                width: 10
+            },
+            file,
+            mimeType: 'image/avif',
+            req: {
+                payloadUploadSizes: {}
+            },
+            savedFilename: 'photo.avif',
+            sharp: sharp,
+            staticPath: '/tmp'
+        });
+        expect(sharp).toHaveBeenCalledWith(file.data, {});
+    });
+});
+
+//# sourceMappingURL=createImageSizes.spec.js.map

package/dist/uploads/image-resizing/createImageSizes.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/image-resizing/createImageSizes.spec.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../../collections/config/types.js'\nimport type { PayloadRequest } from '../../types/index.js'\n\nimport { describe, expect, it, vi } from 'vitest'\n\nimport { createImageSizes } from './createImageSizes.js'\n\nconst createSharpMock = () => {\n  const chain: any = {\n    metadata: vi.fn().mockResolvedValue({ height: 10, orientation: 1, width: 10 }),\n    rotate: vi.fn(() => chain),\n  }\n\n  const sharp = vi.fn(() => chain)\n\n  return sharp\n}\n\nconst createFile = (mimetype: string): PayloadRequest['file'] =>\n  ({\n    data: Buffer.from('original'),\n    mimetype,\n    name: 'photo',\n    size: 8,\n  }) as PayloadRequest['file']\n\n// Larger than the source image, with `withoutEnlargement` left undefined, so\n// `getImageResizeAction` returns `'omit'` before any resize/extract sharp calls run - the initial\n// `sharp(...)` call used to probe the source image's own metadata is all that's under test here.\nconst config = {\n  upload: {\n    imageSizes: [{ name: 'thumb', height: 100, width: 100 }],\n  },\n} as unknown as SanitizedCollectionConfig\n\ndescribe('createImageSizes', () => {\n  it('enables sharp animated reading for tiff, matching isAnimatedImage', async () => {\n    const sharp = createSharpMock()\n    const file = createFile('image/tiff')\n\n    await createImageSizes({\n      config,\n      dimensions: { height: 10, width: 10 },\n      file,\n      mimeType: 'image/tiff',\n      req: { payloadUploadSizes: {} } as PayloadRequest,\n      savedFilename: 'photo.tiff',\n      sharp: sharp as any,\n      staticPath: '/tmp',\n    })\n\n    expect(sharp).toHaveBeenCalledWith(file!.data, { animated: true })\n  })\n\n  it('does not enable sharp animated reading for avif, matching isAnimatedImage', async () => {\n    const sharp = createSharpMock()\n    const file = createFile('image/avif')\n\n    await createImageSizes({\n      config,\n      dimensions: { height: 10, width: 10 },\n      file,\n      mimeType: 'image/avif',\n      req: { payloadUploadSizes: {} } as PayloadRequest,\n      savedFilename: 'photo.avif',\n      sharp: sharp as any,\n      staticPath: '/tmp',\n    })\n\n    expect(sharp).toHaveBeenCalledWith(file!.data, {})\n  })\n})\n"],"names":["describe","expect","it","vi","createImageSizes","createSharpMock","chain","metadata","fn","mockResolvedValue","height","orientation","width","rotate","sharp","createFile","mimetype","data","Buffer","from","name","size","config","upload","imageSizes","file","dimensions","mimeType","req","payloadUploadSizes","savedFilename","staticPath","toHaveBeenCalledWith","animated"],"mappings":"AAGA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,EAAEC,EAAE,QAAQ,SAAQ;AAEjD,SAASC,gBAAgB,QAAQ,wBAAuB;AAExD,MAAMC,kBAAkB;IACtB,MAAMC,QAAa;QACjBC,UAAUJ,GAAGK,EAAE,GAAGC,iBAAiB,CAAC;YAAEC,QAAQ;YAAIC,aAAa;YAAGC,OAAO;QAAG;QAC5EC,QAAQV,GAAGK,EAAE,CAAC,IAAMF;IACtB;IAEA,MAAMQ,QAAQX,GAAGK,EAAE,CAAC,IAAMF;IAE1B,OAAOQ;AACT;AAEA,MAAMC,aAAa,CAACC,WACjB,CAAA;QACCC,MAAMC,OAAOC,IAAI,CAAC;QAClBH;QACAI,MAAM;QACNC,MAAM;IACR,CAAA;AAEF,6EAA6E;AAC7E,kGAAkG;AAClG,iGAAiG;AACjG,MAAMC,SAAS;IACbC,QAAQ;QACNC,YAAY;YAAC;gBAAEJ,MAAM;gBAASV,QAAQ;gBAAKE,OAAO;YAAI;SAAE;IAC1D;AACF;AAEAZ,SAAS,oBAAoB;IAC3BE,GAAG,qEAAqE;QACtE,MAAMY,QAAQT;QACd,MAAMoB,OAAOV,WAAW;QAExB,MAAMX,iBAAiB;YACrBkB;YACAI,YAAY;gBAAEhB,QAAQ;gBAAIE,OAAO;YAAG;YACpCa;YACAE,UAAU;YACVC,KAAK;gBAAEC,oBAAoB,CAAC;YAAE;YAC9BC,eAAe;YACfhB,OAAOA;YACPiB,YAAY;QACd;QAEA9B,OAAOa,OAAOkB,oBAAoB,CAACP,KAAMR,IAAI,EAAE;YAAEgB,UAAU;QAAK;IAClE;IAEA/B,GAAG,6EAA6E;QAC9E,MAAMY,QAAQT;QACd,MAAMoB,OAAOV,WAAW;QAExB,MAAMX,iBAAiB;YACrBkB;YACAI,YAAY;gBAAEhB,QAAQ;gBAAIE,OAAO;YAAG;YACpCa;YACAE,UAAU;YACVC,KAAK;gBAAEC,oBAAoB,CAAC;YAAE;YAC9BC,eAAe;YACfhB,OAAOA;YACPiB,YAAY;QACd;QAEA9B,OAAOa,OAAOkB,oBAAoB,CAACP,KAAMR,IAAI,EAAE,CAAC;IAClD;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"generateImageSizeFilename.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/generateImageSizeFilename.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,KAAK,mBAAmB,GAAG;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,MAAM,CAAA;IACvB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AACD,eAAO,MAAM,yBAAyB,GAAI,gDAKvC,mBAAmB,KAAG,MAExB,CAAA"}
+{"version":3,"file":"generateImageSizeFilename.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/generateImageSizeFilename.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,KAAK,mBAAmB,GAAG;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,MAAM,CAAA;IACvB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AACD,eAAO,MAAM,yBAAyB,mDAKnC,mBAAmB,KAAG,MAExB,CAAA"}

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

@@ -20,5 +20,5 @@ export declare const getImageResizeAction: ({ dimensions: originalImage, hasFoca
     dimensions: ProbedImageSize;
     hasFocalPoint?: boolean;
     imageResizeConfig: ImageSize;
-}) => "omit" | "resize" | "resizeWithFocalPoint";
+}) => 'omit' | 'resize' | 'resizeWithFocalPoint';
 //# sourceMappingURL=getImageResizeAction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getImageResizeAction.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/getImageResizeAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAI7D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,GAAI,kEAIlC;IACD,UAAU,EAAE,eAAe,CAAA;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,SAAS,CAAA;CAC7B,KAAG,MAAM,GAAG,QAAQ,GAAG,sBA8CvB,CAAA"}
+{"version":3,"file":"getImageResizeAction.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/getImageResizeAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAI7D;;;;;;;;;;;;;;;;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/uploads/image-resizing/parseFilename.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseFilename.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/parseFilename.ts"],"names":[],"mappings":"AAEA,KAAK,kBAAkB,GAAG;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,aAAa,MAAM,KAAG,kBAInD,CAAA"}
+{"version":3,"file":"parseFilename.d.ts","sourceRoot":"","sources":["../../../src/uploads/image-resizing/parseFilename.ts"],"names":[],"mappings":"AAEA,KAAK,kBAAkB,GAAG;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,gBAAiB,MAAM,KAAG,kBAInD,CAAA"}

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

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

package/dist/uploads/isAnimatedImage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether sharp needs to read every frame/page of this mime type (rather than just the first) to
+ * process it correctly - used to decide whether a file needs its full bytes fetched/processed
+ * even without any resize/format/trim adjustments configured, and whether sharp should be asked
+ * to read all frames when it does run.
+ */
+export declare function isAnimatedImage(mimeType: string): boolean;
+//# sourceMappingURL=isAnimatedImage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isAnimatedImage.d.ts","sourceRoot":"","sources":["../../src/uploads/isAnimatedImage.ts"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/uploads/isAnimatedImage.js

@@ -0,0 +1,22 @@
+// Matches the formats sharp's own `animated` input option documents as supported (reading every
+// frame/page instead of just the first): https://sharp.pixelplumbing.com/api-constructor - "Set to
+// true to read all frames/pages of an animated image (GIF, WebP, TIFF)". AVIF is deliberately
+// excluded even though the format itself supports animation: this sharp version's AVIF encoder
+// silently flattens `join({ animated: true })` frames into a single tall static image instead of
+// a multi-page sequence (verified directly - the output always comes back as `pages: 1`), so
+// there's no working animated-AVIF path to account for here.
+const ANIMATED_IMAGE_MIME_TYPES = [
+    'image/gif',
+    'image/tiff',
+    'image/webp'
+];
+/**
+ * Whether sharp needs to read every frame/page of this mime type (rather than just the first) to
+ * process it correctly - used to decide whether a file needs its full bytes fetched/processed
+ * even without any resize/format/trim adjustments configured, and whether sharp should be asked
+ * to read all frames when it does run.
+ */ export function isAnimatedImage(mimeType) {
+    return ANIMATED_IMAGE_MIME_TYPES.includes(mimeType);
+}
+
+//# sourceMappingURL=isAnimatedImage.js.map

package/dist/uploads/isAnimatedImage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/isAnimatedImage.ts"],"sourcesContent":["// Matches the formats sharp's own `animated` input option documents as supported (reading every\n// frame/page instead of just the first): https://sharp.pixelplumbing.com/api-constructor - \"Set to\n// true to read all frames/pages of an animated image (GIF, WebP, TIFF)\". AVIF is deliberately\n// excluded even though the format itself supports animation: this sharp version's AVIF encoder\n// silently flattens `join({ animated: true })` frames into a single tall static image instead of\n// a multi-page sequence (verified directly - the output always comes back as `pages: 1`), so\n// there's no working animated-AVIF path to account for here.\nconst ANIMATED_IMAGE_MIME_TYPES = ['image/gif', 'image/tiff', 'image/webp']\n\n/**\n * Whether sharp needs to read every frame/page of this mime type (rather than just the first) to\n * process it correctly - used to decide whether a file needs its full bytes fetched/processed\n * even without any resize/format/trim adjustments configured, and whether sharp should be asked\n * to read all frames when it does run.\n */\nexport function isAnimatedImage(mimeType: string): boolean {\n  return ANIMATED_IMAGE_MIME_TYPES.includes(mimeType)\n}\n"],"names":["ANIMATED_IMAGE_MIME_TYPES","isAnimatedImage","mimeType","includes"],"mappings":"AAAA,gGAAgG;AAChG,mGAAmG;AACnG,8FAA8F;AAC9F,+FAA+F;AAC/F,iGAAiG;AACjG,6FAA6F;AAC7F,6DAA6D;AAC7D,MAAMA,4BAA4B;IAAC;IAAa;IAAc;CAAa;AAE3E;;;;;CAKC,GACD,OAAO,SAASC,gBAAgBC,QAAgB;IAC9C,OAAOF,0BAA0BG,QAAQ,CAACD;AAC5C"}

package/dist/uploads/isAnimatedImage.spec.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { isAnimatedImage } from './isAnimatedImage.js';
+describe('isAnimatedImage', ()=>{
+    it('returns true for the formats sharp documents as supporting its animated option', ()=>{
+        expect(isAnimatedImage('image/gif')).toBe(true);
+        expect(isAnimatedImage('image/webp')).toBe(true);
+        expect(isAnimatedImage('image/tiff')).toBe(true);
+    });
+    it('returns false for avif, since sharp does not read or write multi-frame avif sequences', ()=>{
+        expect(isAnimatedImage('image/avif')).toBe(false);
+    });
+    it('returns false for static-only image formats', ()=>{
+        expect(isAnimatedImage('image/png')).toBe(false);
+        expect(isAnimatedImage('image/jpeg')).toBe(false);
+        expect(isAnimatedImage('image/svg+xml')).toBe(false);
+    });
+});
+
+//# sourceMappingURL=isAnimatedImage.spec.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/isAnimatedImage.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { isAnimatedImage } from './isAnimatedImage.js'\n\ndescribe('isAnimatedImage', () => {\n  it('returns true for the formats sharp documents as supporting its animated option', () => {\n    expect(isAnimatedImage('image/gif')).toBe(true)\n    expect(isAnimatedImage('image/webp')).toBe(true)\n    expect(isAnimatedImage('image/tiff')).toBe(true)\n  })\n\n  it('returns false for avif, since sharp does not read or write multi-frame avif sequences', () => {\n    expect(isAnimatedImage('image/avif')).toBe(false)\n  })\n\n  it('returns false for static-only image formats', () => {\n    expect(isAnimatedImage('image/png')).toBe(false)\n    expect(isAnimatedImage('image/jpeg')).toBe(false)\n    expect(isAnimatedImage('image/svg+xml')).toBe(false)\n  })\n})\n"],"names":["describe","expect","it","isAnimatedImage","toBe"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAE7C,SAASC,eAAe,QAAQ,uBAAsB;AAEtDH,SAAS,mBAAmB;IAC1BE,GAAG,kFAAkF;QACnFD,OAAOE,gBAAgB,cAAcC,IAAI,CAAC;QAC1CH,OAAOE,gBAAgB,eAAeC,IAAI,CAAC;QAC3CH,OAAOE,gBAAgB,eAAeC,IAAI,CAAC;IAC7C;IAEAF,GAAG,yFAAyF;QAC1FD,OAAOE,gBAAgB,eAAeC,IAAI,CAAC;IAC7C;IAEAF,GAAG,+CAA+C;QAChDD,OAAOE,gBAAgB,cAAcC,IAAI,CAAC;QAC1CH,OAAOE,gBAAgB,eAAeC,IAAI,CAAC;QAC3CH,OAAOE,gBAAgB,kBAAkBC,IAAI,CAAC;IAChD;AACF"}

package/dist/uploads/matchMimeType.d.ts

@@ -0,0 +1,8 @@
+import type { PayloadComponent } from '../config/types.js';
+/**
+ * Resolves a PayloadComponent from a MIME-type keyed map.
+ *
+ * Priority: exact match → category wildcard (e.g. `video/*`) → universal fallback (`*`).
+ */
+export declare function matchMimeType(map: Record<string, PayloadComponent>, mimeType: string): PayloadComponent | undefined;
+//# sourceMappingURL=matchMimeType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchMimeType.d.ts","sourceRoot":"","sources":["../../src/uploads/matchMimeType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE1D;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACrC,QAAQ,EAAE,MAAM,GACf,gBAAgB,GAAG,SAAS,CAY9B"}

package/dist/uploads/matchMimeType.js

@@ -0,0 +1,19 @@
+/**
+ * Resolves a PayloadComponent from a MIME-type keyed map.
+ *
+ * Priority: exact match → category wildcard (e.g. `video/*`) → universal fallback (`*`).
+ */ export function matchMimeType(map, mimeType) {
+    if (mimeType in map) {
+        return map[mimeType];
+    }
+    const category = mimeType.split('/')[0];
+    if (`${category}/*` in map) {
+        return map[`${category}/*`];
+    }
+    if ('*' in map) {
+        return map['*'];
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=matchMimeType.js.map

package/dist/uploads/matchMimeType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/matchMimeType.ts"],"sourcesContent":["import type { PayloadComponent } from '../config/types.js'\n\n/**\n * Resolves a PayloadComponent from a MIME-type keyed map.\n *\n * Priority: exact match → category wildcard (e.g. `video/*`) → universal fallback (`*`).\n */\nexport function matchMimeType(\n  map: Record<string, PayloadComponent>,\n  mimeType: string,\n): PayloadComponent | undefined {\n  if (mimeType in map) {\n    return map[mimeType]\n  }\n  const category = mimeType.split('/')[0]\n  if (`${category}/*` in map) {\n    return map[`${category}/*`]\n  }\n  if ('*' in map) {\n    return map['*']\n  }\n  return undefined\n}\n"],"names":["matchMimeType","map","mimeType","category","split","undefined"],"mappings":"AAEA;;;;CAIC,GACD,OAAO,SAASA,cACdC,GAAqC,EACrCC,QAAgB;IAEhB,IAAIA,YAAYD,KAAK;QACnB,OAAOA,GAAG,CAACC,SAAS;IACtB;IACA,MAAMC,WAAWD,SAASE,KAAK,CAAC,IAAI,CAAC,EAAE;IACvC,IAAI,GAAGD,SAAS,EAAE,CAAC,IAAIF,KAAK;QAC1B,OAAOA,GAAG,CAAC,GAAGE,SAAS,EAAE,CAAC,CAAC;IAC7B;IACA,IAAI,OAAOF,KAAK;QACd,OAAOA,GAAG,CAAC,IAAI;IACjB;IACA,OAAOI;AACT"}

package/dist/uploads/matchMimeType.spec.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { matchMimeType } from './matchMimeType.js';
+describe('matchMimeType', ()=>{
+    it('should return the exact match when present', ()=>{
+        const map = {
+            'image/png': 'PngComponent',
+            '*': 'FallbackComponent'
+        };
+        expect(matchMimeType(map, 'image/png')).toBe('PngComponent');
+    });
+    it('should fall back to the category wildcard when no exact match exists', ()=>{
+        const map = {
+            'image/*': 'ImageComponent',
+            '*': 'FallbackComponent'
+        };
+        expect(matchMimeType(map, 'image/png')).toBe('ImageComponent');
+    });
+    it('should fall back to the universal wildcard when no exact or category match exists', ()=>{
+        const map = {
+            'video/*': 'VideoComponent',
+            '*': 'FallbackComponent'
+        };
+        expect(matchMimeType(map, 'image/png')).toBe('FallbackComponent');
+    });
+    it('should return undefined when no entry matches', ()=>{
+        const map = {
+            'video/*': 'VideoComponent'
+        };
+        expect(matchMimeType(map, 'image/png')).toBeUndefined();
+    });
+    it('should honor an explicit `false` exact match and not fall through to the wildcard', ()=>{
+        const map = {
+            'image/png': false,
+            '*': 'FallbackComponent'
+        };
+        expect(matchMimeType(map, 'image/png')).toBe(false);
+    });
+    it('should honor an explicit `false` category wildcard and not fall through to the universal wildcard', ()=>{
+        const map = {
+            'image/*': false,
+            '*': 'FallbackComponent'
+        };
+        expect(matchMimeType(map, 'image/png')).toBe(false);
+    });
+    it('should handle an empty-string mime type by falling back to the universal wildcard', ()=>{
+        const map = {
+            '*': 'FallbackComponent'
+        };
+        expect(matchMimeType(map, '')).toBe('FallbackComponent');
+    });
+    it('should handle a mime type without a slash', ()=>{
+        const map = {
+            'image/*': 'ImageComponent',
+            '*': 'FallbackComponent'
+        };
+        expect(matchMimeType(map, 'notamimetype')).toBe('FallbackComponent');
+    });
+    it('should match case-sensitively', ()=>{
+        const map = {
+            'image/png': 'PngComponent'
+        };
+        expect(matchMimeType(map, 'IMAGE/PNG')).toBeUndefined();
+    });
+});
+
+//# sourceMappingURL=matchMimeType.spec.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/matchMimeType.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { matchMimeType } from './matchMimeType.js'\n\ndescribe('matchMimeType', () => {\n  it('should return the exact match when present', () => {\n    const map = { 'image/png': 'PngComponent', '*': 'FallbackComponent' }\n    expect(matchMimeType(map, 'image/png')).toBe('PngComponent')\n  })\n\n  it('should fall back to the category wildcard when no exact match exists', () => {\n    const map = { 'image/*': 'ImageComponent', '*': 'FallbackComponent' }\n    expect(matchMimeType(map, 'image/png')).toBe('ImageComponent')\n  })\n\n  it('should fall back to the universal wildcard when no exact or category match exists', () => {\n    const map = { 'video/*': 'VideoComponent', '*': 'FallbackComponent' }\n    expect(matchMimeType(map, 'image/png')).toBe('FallbackComponent')\n  })\n\n  it('should return undefined when no entry matches', () => {\n    const map = { 'video/*': 'VideoComponent' }\n    expect(matchMimeType(map, 'image/png')).toBeUndefined()\n  })\n\n  it('should honor an explicit `false` exact match and not fall through to the wildcard', () => {\n    const map = { 'image/png': false as const, '*': 'FallbackComponent' }\n    expect(matchMimeType(map, 'image/png')).toBe(false)\n  })\n\n  it('should honor an explicit `false` category wildcard and not fall through to the universal wildcard', () => {\n    const map = { 'image/*': false as const, '*': 'FallbackComponent' }\n    expect(matchMimeType(map, 'image/png')).toBe(false)\n  })\n\n  it('should handle an empty-string mime type by falling back to the universal wildcard', () => {\n    const map = { '*': 'FallbackComponent' }\n    expect(matchMimeType(map, '')).toBe('FallbackComponent')\n  })\n\n  it('should handle a mime type without a slash', () => {\n    const map = { 'image/*': 'ImageComponent', '*': 'FallbackComponent' }\n    expect(matchMimeType(map, 'notamimetype')).toBe('FallbackComponent')\n  })\n\n  it('should match case-sensitively', () => {\n    const map = { 'image/png': 'PngComponent' }\n    expect(matchMimeType(map, 'IMAGE/PNG')).toBeUndefined()\n  })\n})\n"],"names":["describe","expect","it","matchMimeType","map","toBe","toBeUndefined"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAE7C,SAASC,aAAa,QAAQ,qBAAoB;AAElDH,SAAS,iBAAiB;IACxBE,GAAG,8CAA8C;QAC/C,MAAME,MAAM;YAAE,aAAa;YAAgB,KAAK;QAAoB;QACpEH,OAAOE,cAAcC,KAAK,cAAcC,IAAI,CAAC;IAC/C;IAEAH,GAAG,wEAAwE;QACzE,MAAME,MAAM;YAAE,WAAW;YAAkB,KAAK;QAAoB;QACpEH,OAAOE,cAAcC,KAAK,cAAcC,IAAI,CAAC;IAC/C;IAEAH,GAAG,qFAAqF;QACtF,MAAME,MAAM;YAAE,WAAW;YAAkB,KAAK;QAAoB;QACpEH,OAAOE,cAAcC,KAAK,cAAcC,IAAI,CAAC;IAC/C;IAEAH,GAAG,iDAAiD;QAClD,MAAME,MAAM;YAAE,WAAW;QAAiB;QAC1CH,OAAOE,cAAcC,KAAK,cAAcE,aAAa;IACvD;IAEAJ,GAAG,qFAAqF;QACtF,MAAME,MAAM;YAAE,aAAa;YAAgB,KAAK;QAAoB;QACpEH,OAAOE,cAAcC,KAAK,cAAcC,IAAI,CAAC;IAC/C;IAEAH,GAAG,qGAAqG;QACtG,MAAME,MAAM;YAAE,WAAW;YAAgB,KAAK;QAAoB;QAClEH,OAAOE,cAAcC,KAAK,cAAcC,IAAI,CAAC;IAC/C;IAEAH,GAAG,qFAAqF;QACtF,MAAME,MAAM;YAAE,KAAK;QAAoB;QACvCH,OAAOE,cAAcC,KAAK,KAAKC,IAAI,CAAC;IACtC;IAEAH,GAAG,6CAA6C;QAC9C,MAAME,MAAM;YAAE,WAAW;YAAkB,KAAK;QAAoB;QACpEH,OAAOE,cAAcC,KAAK,iBAAiBC,IAAI,CAAC;IAClD;IAEAH,GAAG,iCAAiC;QAClC,MAAME,MAAM;YAAE,aAAa;QAAe;QAC1CH,OAAOE,cAAcC,KAAK,cAAcE,aAAa;IACvD;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"mimeTypeValidator.d.ts","sourceRoot":"","sources":["../../src/uploads/mimeTypeValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAIzD,eAAO,MAAM,iBAAiB,GAC3B,WAAW,MAAM,EAAE,KAAG,QAYtB,CAAA"}
+{"version":3,"file":"mimeTypeValidator.d.ts","sourceRoot":"","sources":["../../src/uploads/mimeTypeValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAIzD,eAAO,MAAM,iBAAiB,cAChB,MAAM,EAAE,KAAG,QAYtB,CAAA"}

package/dist/uploads/probeImageSize.d.ts

@@ -0,0 +1,39 @@
+import type { ProbedImageSize } from './types.js';
+/**
+ * Image dimension probe used as a fallback when `sharp` is not configured.
+ * Reads only the header bytes needed to determine width and height.
+ *
+ * PNG, JPEG, GIF, WebP, AVIF and HEIF/HEIC are delegated to `image-dimensions`
+ * (actively maintained, zero dependencies). BMP, ICO/CUR, SVG, TIFF and JPEG
+ * XL have no such maintained equivalent, so they're read here directly; each
+ * of those parsers advances by a fixed amount or is bounded by an explicit
+ * guard, so malformed input can never block the event loop.
+ *
+ * Replaces the archived `image-size` package, whose ICNS/HEIF parsers shipped
+ * unpatched denial-of-service vulnerabilities (CVE-2025-71330, CVE-2025-71319).
+ *
+ * Two edge cases changed behavior compared to the previous hand-rolled parser:
+ * - JPEG files using arithmetic coding or hierarchical encoding (SOF markers
+ *   5-7, 9-11, 13-15) are no longer read; `image-dimensions` only recognizes
+ *   baseline and progressive JPEG (SOF0-3). These encodings are not produced
+ *   by browsers or cameras, so this is not expected to affect real uploads.
+ * - AVIF/HEIF detection now checks the container's brand list instead of
+ *   accepting any ISO base media file with a `ftyp` box, so non-image formats
+ *   that share the same container (for example MP4/MOV) are correctly no
+ *   longer misidentified as images.
+ *
+ * @throws if the buffer is not a recognized/parseable image format
+ */
+export declare function probeImageSize(data: Buffer): ProbedImageSize;
+/**
+ * Probe used when the file lives on disk via `tempFilePath`. PNG, JPEG, GIF,
+ * WebP, AVIF and HEIF/HEIC are read through `imageDimensionsFromStream`,
+ * which reads only as many bytes as are needed to find the header, so a
+ * large file's data is never pulled into memory. BMP, ICO/CUR, SVG, TIFF and
+ * JPEG XL are detected from a small header sniff and, only then, read in
+ * full for `probeImageSize` to parse.
+ *
+ * @throws if the file is not a recognized/parseable image format
+ */
+export declare function probeImageSizeFromPath(tempFilePath: string): Promise<ProbedImageSize>;
+//# sourceMappingURL=probeImageSize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probeImageSize.d.ts","sourceRoot":"","sources":["../../src/uploads/probeImageSize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAW5D;AAQD;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAgB3F"}