830 lines
25 KiB
TypeScript
830 lines
25 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest';
|
||
import {
|
||
calculateImageResizeTarget,
|
||
estimateSelectedImageTokens,
|
||
getEffectiveImageMimeType,
|
||
getImageEncodeCandidates,
|
||
getImageFileNameForMime,
|
||
IMAGE_MAX_AUTO_PROCESS_SOURCE_BYTES,
|
||
processImageAttachment,
|
||
shouldSkipAutomaticImageProcessing,
|
||
type BrowserImageCodec,
|
||
type DecodedImage,
|
||
type RenderedImage,
|
||
} from '@/lib/image-attachment-compression';
|
||
import { browserImageCodec } from '@/lib/browser-image-codec';
|
||
|
||
function createDeferred<T>() {
|
||
let resolve!: (value: T | PromiseLike<T>) => void;
|
||
let reject!: (reason?: unknown) => void;
|
||
const promise = new Promise<T>((promiseResolve, promiseReject) => {
|
||
resolve = promiseResolve;
|
||
reject = promiseReject;
|
||
});
|
||
return { promise, reject, resolve };
|
||
}
|
||
|
||
describe('calculateImageResizeTarget', () => {
|
||
it('keeps a small image unchanged', () => {
|
||
expect(calculateImageResizeTarget(1280, 720)).toEqual({
|
||
width: 1280,
|
||
height: 720,
|
||
scale: 1,
|
||
resized: false,
|
||
});
|
||
});
|
||
|
||
it('caps a 4K image by the pixel limit', () => {
|
||
const target = calculateImageResizeTarget(3840, 2160);
|
||
expect(target).toEqual({
|
||
width: 1930,
|
||
height: 1086,
|
||
scale: expect.closeTo(Math.sqrt(2_097_152 / (3840 * 2160)), 8),
|
||
resized: true,
|
||
});
|
||
expect(target.width * target.height).toBeLessThanOrEqual(2_097_152);
|
||
});
|
||
|
||
it('caps a very wide image by the long edge and never returns zero', () => {
|
||
expect(calculateImageResizeTarget(4096, 256)).toMatchObject({
|
||
width: 2048,
|
||
height: 128,
|
||
resized: true,
|
||
});
|
||
expect(calculateImageResizeTarget(100_000, 1)).toMatchObject({
|
||
width: 2048,
|
||
height: 1,
|
||
resized: true,
|
||
});
|
||
});
|
||
|
||
it.each([
|
||
[Number.NaN, 10],
|
||
[Number.POSITIVE_INFINITY, 10],
|
||
[10, Number.NEGATIVE_INFINITY],
|
||
[0, 10],
|
||
[-1, 10],
|
||
[10, 0],
|
||
])('rejects invalid dimensions %s × %s', (width, height) => {
|
||
expect(() => calculateImageResizeTarget(width, height))
|
||
.toThrowError(new RangeError('Image dimensions must be finite positive numbers'));
|
||
});
|
||
});
|
||
|
||
describe('image MIME and encoding rules', () => {
|
||
it('infers a missing MIME from the filename', () => {
|
||
expect(getEffectiveImageMimeType(new File([], 'animation.GIF'))).toBe('image/gif');
|
||
expect(getEffectiveImageMimeType(new File([], 'vector.svg'))).toBe('image/svg+xml');
|
||
expect(getEffectiveImageMimeType(new File([], 'unknown.bin'))).toBe('application/octet-stream');
|
||
});
|
||
|
||
it.each(['image/gif', 'IMAGE/GIF', 'image/svg+xml'])('skips %s immediately', (mimeType) => {
|
||
expect(shouldSkipAutomaticImageProcessing(mimeType)).toBe(true);
|
||
});
|
||
|
||
it('selects lossless output for PNG and BMP', () => {
|
||
expect(getImageEncodeCandidates('image/png', true)).toEqual([
|
||
{ mimeType: 'image/png' },
|
||
]);
|
||
expect(getImageEncodeCandidates('image/bmp', false)).toEqual([
|
||
{ mimeType: 'image/png' },
|
||
]);
|
||
});
|
||
|
||
it('selects JPEG quality and WebP fallbacks deterministically', () => {
|
||
expect(getImageEncodeCandidates('image/jpeg', false)).toEqual([
|
||
{ mimeType: 'image/jpeg', quality: 0.85 },
|
||
]);
|
||
expect(getImageEncodeCandidates('image/webp', true)).toEqual([
|
||
{ mimeType: 'image/webp', quality: 0.85 },
|
||
{ mimeType: 'image/png' },
|
||
]);
|
||
expect(getImageEncodeCandidates('image/avif', false)).toEqual([
|
||
{ mimeType: 'image/webp', quality: 0.85 },
|
||
{ mimeType: 'image/jpeg', quality: 0.85 },
|
||
]);
|
||
});
|
||
|
||
it('makes transport filename extensions match the selected MIME', () => {
|
||
expect(getImageFileNameForMime('capture.bmp', 'image/png')).toBe('capture.png');
|
||
expect(getImageFileNameForMime('photo.avif', 'image/webp')).toBe('photo.webp');
|
||
expect(getImageFileNameForMime('photo.avif', 'image/jpeg')).toBe('photo.jpg');
|
||
expect(getImageFileNameForMime('photo.jpeg', 'image/jpg')).toBe('photo.jpg');
|
||
expect(getImageFileNameForMime('.hidden', 'image/png')).toBe('.hidden.png');
|
||
expect(getImageFileNameForMime('notes.txt', 'text/plain')).toBe('notes.txt');
|
||
});
|
||
});
|
||
|
||
describe('estimateSelectedImageTokens', () => {
|
||
it('delegates only an imported Qwen Plus model to the shared profile', () => {
|
||
expect(estimateSelectedImageTokens(
|
||
'niancode-user-models/qwen3.7-plus',
|
||
3840,
|
||
2160,
|
||
)).toBe(8102);
|
||
expect(estimateSelectedImageTokens(
|
||
'niancode-user-models/qwen3.7-plus',
|
||
1930,
|
||
1086,
|
||
)).toBe(2049);
|
||
});
|
||
|
||
it('returns null for unverified models and a same-named model on another provider', () => {
|
||
expect(estimateSelectedImageTokens(
|
||
'niancode-user-models/qwen-vl-max',
|
||
1930,
|
||
1086,
|
||
)).toBeNull();
|
||
expect(estimateSelectedImageTokens(
|
||
'openai/qwen3.7-plus',
|
||
1930,
|
||
1086,
|
||
)).toBeNull();
|
||
expect(estimateSelectedImageTokens('qwen3.7-plus', 1930, 1086)).toBeNull();
|
||
expect(estimateSelectedImageTokens(
|
||
'niancode-user-models/qwen3.7-plus/extra',
|
||
1930,
|
||
1086,
|
||
)).toBeNull();
|
||
});
|
||
});
|
||
|
||
function createFakeCodec(options: {
|
||
frameCount?: number | null;
|
||
width?: number;
|
||
height?: number;
|
||
hasAlpha?: boolean;
|
||
encoded?: Array<Blob | null>;
|
||
}) {
|
||
const decoded: DecodedImage = {
|
||
source: {} as CanvasImageSource,
|
||
width: options.width ?? 3840,
|
||
height: options.height ?? 2160,
|
||
dispose: vi.fn(),
|
||
};
|
||
const rendered: RenderedImage = {
|
||
canvas: {} as HTMLCanvasElement,
|
||
hasAlpha: options.hasAlpha ?? false,
|
||
dispose: vi.fn(),
|
||
};
|
||
const encoded = [...(options.encoded ?? [])];
|
||
const codec = {
|
||
inspectFrameCount: vi.fn(async () => (
|
||
Object.prototype.hasOwnProperty.call(options, 'frameCount')
|
||
? options.frameCount ?? null
|
||
: 1
|
||
)),
|
||
decode: vi.fn(async () => decoded),
|
||
render: vi.fn(() => rendered),
|
||
encode: vi.fn(async () => encoded.shift() ?? null),
|
||
} satisfies BrowserImageCodec;
|
||
return { codec, decoded, rendered };
|
||
}
|
||
|
||
describe('processImageAttachment', () => {
|
||
it('keeps an over-limit encoded source sendable without invoking the codec', async () => {
|
||
const { codec } = createFakeCodec({});
|
||
const file = new File([], 'huge.png', { type: 'image/png' });
|
||
Object.defineProperty(file, 'size', {
|
||
configurable: true,
|
||
value: IMAGE_MAX_AUTO_PROCESS_SOURCE_BYTES + 1,
|
||
});
|
||
|
||
await expect(processImageAttachment(file, codec)).resolves.toMatchObject({
|
||
status: 'skipped',
|
||
original: {
|
||
blob: file,
|
||
mimeType: 'image/png',
|
||
bytes: IMAGE_MAX_AUTO_PROCESS_SOURCE_BYTES + 1,
|
||
},
|
||
defaultVariant: 'original',
|
||
skipReason: 'source-too-large',
|
||
warning: expect.any(String),
|
||
});
|
||
expect(codec.inspectFrameCount).not.toHaveBeenCalled();
|
||
expect(codec.decode).not.toHaveBeenCalled();
|
||
expect(codec.render).not.toHaveBeenCalled();
|
||
expect(codec.encode).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('inspects one frame, honors EXIF orientation, resizes, and uses WebP first', async () => {
|
||
const compressed = new Blob(['compressed'], { type: 'image/webp' });
|
||
const { codec, decoded, rendered } = createFakeCodec({
|
||
frameCount: 1,
|
||
encoded: [compressed],
|
||
});
|
||
const file = new File(['original'], 'photo.avif', { type: 'image/avif' });
|
||
|
||
const result = await processImageAttachment(file, codec);
|
||
|
||
expect(codec.inspectFrameCount).toHaveBeenCalledWith(
|
||
file,
|
||
'image/avif',
|
||
undefined,
|
||
);
|
||
expect(codec.decode).toHaveBeenCalledWith(file, {
|
||
imageOrientation: 'from-image',
|
||
}, undefined);
|
||
expect(codec.render).toHaveBeenCalledWith(decoded, {
|
||
width: 1930,
|
||
height: 1086,
|
||
}, undefined);
|
||
expect(codec.encode).toHaveBeenCalledWith(rendered, {
|
||
mimeType: 'image/webp',
|
||
quality: 0.85,
|
||
}, undefined);
|
||
expect(result).toMatchObject({
|
||
status: 'compressed',
|
||
defaultVariant: 'compressed',
|
||
compressed: {
|
||
blob: compressed,
|
||
mimeType: 'image/webp',
|
||
width: 1930,
|
||
height: 1086,
|
||
},
|
||
});
|
||
expect(decoded.dispose).toHaveBeenCalledTimes(1);
|
||
expect(rendered.dispose).toHaveBeenCalledTimes(1);
|
||
});
|
||
|
||
it('falls back from unsupported WebP to PNG for an alpha image', async () => {
|
||
const png = new Blob(['png'], { type: 'image/png' });
|
||
const { codec } = createFakeCodec({
|
||
frameCount: 1,
|
||
hasAlpha: true,
|
||
encoded: [null, png],
|
||
});
|
||
|
||
const result = await processImageAttachment(
|
||
new File(['original'], 'alpha.avif', { type: 'image/avif' }),
|
||
codec,
|
||
);
|
||
|
||
expect(codec.encode).toHaveBeenNthCalledWith(1, expect.anything(), {
|
||
mimeType: 'image/webp',
|
||
quality: 0.85,
|
||
}, undefined);
|
||
expect(codec.encode).toHaveBeenNthCalledWith(2, expect.anything(), {
|
||
mimeType: 'image/png',
|
||
}, undefined);
|
||
expect(result).toMatchObject({
|
||
status: 'compressed',
|
||
compressed: { mimeType: 'image/png' },
|
||
});
|
||
});
|
||
|
||
it.each([
|
||
['image/png', 'animated.png'],
|
||
['image/webp', 'animated.webp'],
|
||
['image/avif', 'animated.avif'],
|
||
])('skips multi-frame %s without decoding its first frame', async (mimeType, name) => {
|
||
const { codec } = createFakeCodec({ frameCount: 3 });
|
||
const result = await processImageAttachment(
|
||
new File(['animated'], name, { type: mimeType }),
|
||
codec,
|
||
);
|
||
|
||
expect(result).toMatchObject({
|
||
status: 'skipped',
|
||
skipReason: 'animated',
|
||
defaultVariant: 'original',
|
||
warning: '检测到动画图片，已保留原图。',
|
||
});
|
||
expect(codec.decode).not.toHaveBeenCalled();
|
||
expect(codec.render).not.toHaveBeenCalled();
|
||
expect(codec.encode).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('skips an animation-capable raster when single-frame status is unknown', async () => {
|
||
const { codec } = createFakeCodec({ frameCount: null });
|
||
const result = await processImageAttachment(
|
||
new File(['unknown'], 'unknown.webp', { type: 'image/webp' }),
|
||
codec,
|
||
);
|
||
|
||
expect(result).toMatchObject({
|
||
status: 'skipped',
|
||
skipReason: 'static-unverified',
|
||
warning: '无法确认图片为单帧，已保留原图。',
|
||
});
|
||
expect(codec.decode).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it.each([
|
||
['image/gif', 'animation.gif', 'animated'],
|
||
['image/svg+xml', 'vector.svg', 'vector'],
|
||
] as const)('skips %s before frame inspection', async (mimeType, name, skipReason) => {
|
||
const { codec } = createFakeCodec({});
|
||
const result = await processImageAttachment(
|
||
new File(['original'], name, { type: mimeType }),
|
||
codec,
|
||
);
|
||
|
||
expect(result).toMatchObject({
|
||
status: 'skipped',
|
||
skipReason,
|
||
defaultVariant: 'original',
|
||
});
|
||
expect(codec.inspectFrameCount).not.toHaveBeenCalled();
|
||
expect(codec.decode).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('does not render or encode a small one-frame image', async () => {
|
||
const { codec } = createFakeCodec({
|
||
frameCount: 1,
|
||
width: 1280,
|
||
height: 720,
|
||
});
|
||
const result = await processImageAttachment(
|
||
new File(['small'], 'small.jpg', { type: 'image/jpeg' }),
|
||
codec,
|
||
);
|
||
|
||
expect(result).toMatchObject({
|
||
status: 'unchanged',
|
||
defaultVariant: 'original',
|
||
original: { width: 1280, height: 720 },
|
||
});
|
||
expect(codec.render).not.toHaveBeenCalled();
|
||
expect(codec.encode).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('fails open when decode throws', async () => {
|
||
const { codec } = createFakeCodec({ frameCount: 1 });
|
||
codec.decode.mockRejectedValueOnce(new Error('decode failed'));
|
||
const file = new File(['original'], 'broken.png', { type: 'image/png' });
|
||
|
||
await expect(processImageAttachment(file, codec)).resolves.toEqual({
|
||
status: 'failed',
|
||
original: {
|
||
blob: file,
|
||
mimeType: 'image/png',
|
||
bytes: file.size,
|
||
},
|
||
defaultVariant: 'original',
|
||
warning: '图片压缩失败，发送时将使用原图。',
|
||
});
|
||
});
|
||
|
||
it('fails open when every MIME encoder is unsupported', async () => {
|
||
const { codec } = createFakeCodec({
|
||
frameCount: 1,
|
||
hasAlpha: false,
|
||
encoded: [null, null],
|
||
});
|
||
|
||
const result = await processImageAttachment(
|
||
new File(['original'], 'photo.avif', { type: 'image/avif' }),
|
||
codec,
|
||
);
|
||
|
||
expect(result).toMatchObject({
|
||
status: 'failed',
|
||
defaultVariant: 'original',
|
||
warning: '图片压缩失败，发送时将使用原图。',
|
||
});
|
||
});
|
||
|
||
it('preserves decoded original dimensions when rendering later fails', async () => {
|
||
const { codec } = createFakeCodec({
|
||
frameCount: 1,
|
||
width: 3000,
|
||
height: 2000,
|
||
});
|
||
codec.render.mockImplementationOnce(() => {
|
||
throw new Error('render failed');
|
||
});
|
||
const file = new File(['original'], 'photo.png', { type: 'image/png' });
|
||
|
||
await expect(processImageAttachment(file, codec)).resolves.toMatchObject({
|
||
status: 'failed',
|
||
original: {
|
||
blob: file,
|
||
width: 3000,
|
||
height: 2000,
|
||
},
|
||
defaultVariant: 'original',
|
||
});
|
||
});
|
||
|
||
it('releases decoded and rendered resources when aborting after render', async () => {
|
||
const controller = new AbortController();
|
||
const { codec, decoded, rendered } = createFakeCodec({
|
||
frameCount: 1,
|
||
width: 3000,
|
||
height: 2000,
|
||
});
|
||
codec.render.mockImplementationOnce(() => {
|
||
controller.abort();
|
||
return rendered;
|
||
});
|
||
|
||
await expect(processImageAttachment(
|
||
new File(['original'], 'photo.png', { type: 'image/png' }),
|
||
codec,
|
||
{ signal: controller.signal },
|
||
)).rejects.toMatchObject({ name: 'AbortError' });
|
||
expect(decoded.dispose).toHaveBeenCalledTimes(1);
|
||
expect(rendered.dispose).toHaveBeenCalledTimes(1);
|
||
expect(codec.encode).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('releases resources when an encode completes after cancellation', async () => {
|
||
const controller = new AbortController();
|
||
const { codec, decoded, rendered } = createFakeCodec({
|
||
frameCount: 1,
|
||
width: 3000,
|
||
height: 2000,
|
||
});
|
||
codec.encode.mockImplementationOnce(async () => {
|
||
controller.abort();
|
||
return new Blob(['compressed'], { type: 'image/png' });
|
||
});
|
||
|
||
await expect(processImageAttachment(
|
||
new File(['original'], 'photo.png', { type: 'image/png' }),
|
||
codec,
|
||
{ signal: controller.signal },
|
||
)).rejects.toMatchObject({ name: 'AbortError' });
|
||
expect(decoded.dispose).toHaveBeenCalledTimes(1);
|
||
expect(rendered.dispose).toHaveBeenCalledTimes(1);
|
||
});
|
||
|
||
it('preserves a compressed result when rendered cleanup throws', async () => {
|
||
const compressed = new Blob(['compressed'], { type: 'image/webp' });
|
||
const { codec, decoded, rendered } = createFakeCodec({
|
||
frameCount: 1,
|
||
encoded: [compressed],
|
||
});
|
||
rendered.dispose = vi.fn(() => {
|
||
throw new Error('rendered cleanup failed');
|
||
});
|
||
decoded.dispose = vi.fn(() => {
|
||
throw new Error('decoded cleanup failed');
|
||
});
|
||
|
||
await expect(processImageAttachment(
|
||
new File(['original'], 'photo.avif', { type: 'image/avif' }),
|
||
codec,
|
||
)).resolves.toMatchObject({
|
||
status: 'compressed',
|
||
defaultVariant: 'compressed',
|
||
compressed: { blob: compressed },
|
||
});
|
||
expect(rendered.dispose).toHaveBeenCalledTimes(1);
|
||
expect(decoded.dispose).toHaveBeenCalledTimes(1);
|
||
});
|
||
|
||
it('preserves an unchanged result when decoded cleanup throws', async () => {
|
||
const { codec, decoded } = createFakeCodec({
|
||
frameCount: 1,
|
||
width: 1280,
|
||
height: 720,
|
||
});
|
||
decoded.dispose = vi.fn(() => {
|
||
throw new Error('decoded cleanup failed');
|
||
});
|
||
|
||
await expect(processImageAttachment(
|
||
new File(['original'], 'small.jpg', { type: 'image/jpeg' }),
|
||
codec,
|
||
)).resolves.toMatchObject({
|
||
status: 'unchanged',
|
||
defaultVariant: 'original',
|
||
original: { width: 1280, height: 720 },
|
||
});
|
||
expect(decoded.dispose).toHaveBeenCalledTimes(1);
|
||
});
|
||
});
|
||
|
||
describe('browserImageCodec', () => {
|
||
it('passes a Blob stream to ImageDecoder without buffering the whole source', async () => {
|
||
const stream = {} as ReadableStream<Uint8Array>;
|
||
const blob = new Blob(['png'], { type: 'image/png' });
|
||
const arrayBuffer = vi.spyOn(blob, 'arrayBuffer');
|
||
Object.defineProperty(blob, 'stream', {
|
||
configurable: true,
|
||
value: vi.fn(() => stream),
|
||
});
|
||
let decoderData: unknown;
|
||
class FakeImageDecoder {
|
||
static isTypeSupported = vi.fn(async () => true);
|
||
|
||
tracks = {
|
||
ready: Promise.resolve(),
|
||
selectedTrack: { frameCount: 1 },
|
||
};
|
||
|
||
close = vi.fn();
|
||
|
||
constructor(init: { data: unknown }) {
|
||
decoderData = init.data;
|
||
}
|
||
}
|
||
vi.stubGlobal('ImageDecoder', FakeImageDecoder);
|
||
|
||
try {
|
||
await expect(browserImageCodec.inspectFrameCount(
|
||
blob,
|
||
'image/png',
|
||
)).resolves.toBe(1);
|
||
expect(decoderData).toBe(stream);
|
||
expect(arrayBuffer).not.toHaveBeenCalled();
|
||
} finally {
|
||
vi.unstubAllGlobals();
|
||
}
|
||
});
|
||
|
||
it('does not create a fallback ImageDecoder after buffering is aborted', async () => {
|
||
const buffered = createDeferred<ArrayBuffer>();
|
||
const blob = new Blob(['png'], { type: 'image/png' });
|
||
const arrayBuffer = vi.spyOn(blob, 'arrayBuffer')
|
||
.mockImplementation(() => buffered.promise);
|
||
Object.defineProperty(blob, 'stream', {
|
||
configurable: true,
|
||
value: vi.fn(() => {
|
||
throw new TypeError('ReadableStream input is unsupported');
|
||
}),
|
||
});
|
||
const construct = vi.fn();
|
||
class FakeImageDecoder {
|
||
static isTypeSupported = vi.fn(async () => true);
|
||
|
||
tracks = {
|
||
ready: Promise.resolve(),
|
||
selectedTrack: { frameCount: 1 },
|
||
};
|
||
|
||
close = vi.fn();
|
||
|
||
constructor() {
|
||
construct();
|
||
}
|
||
}
|
||
vi.stubGlobal('ImageDecoder', FakeImageDecoder);
|
||
const controller = new AbortController();
|
||
|
||
try {
|
||
const inspected = browserImageCodec.inspectFrameCount(
|
||
blob,
|
||
'image/png',
|
||
controller.signal,
|
||
);
|
||
await vi.waitFor(() => expect(arrayBuffer).toHaveBeenCalledTimes(1));
|
||
controller.abort();
|
||
buffered.resolve(new ArrayBuffer(3));
|
||
|
||
await expect(inspected).rejects.toMatchObject({ name: 'AbortError' });
|
||
expect(construct).not.toHaveBeenCalled();
|
||
} finally {
|
||
vi.unstubAllGlobals();
|
||
}
|
||
});
|
||
|
||
it('closes ImageDecoder and rejects when frame inspection is aborted', async () => {
|
||
const ready = createDeferred<void>();
|
||
const close = vi.fn();
|
||
const construct = vi.fn();
|
||
class FakeImageDecoder {
|
||
static isTypeSupported = vi.fn(async () => true);
|
||
|
||
tracks = {
|
||
ready: ready.promise,
|
||
selectedTrack: { frameCount: 1 },
|
||
};
|
||
|
||
close = close;
|
||
|
||
constructor() {
|
||
construct();
|
||
}
|
||
}
|
||
vi.stubGlobal('ImageDecoder', FakeImageDecoder);
|
||
const controller = new AbortController();
|
||
|
||
try {
|
||
const inspected = browserImageCodec.inspectFrameCount(
|
||
new Blob(['png'], { type: 'image/png' }),
|
||
'image/png',
|
||
controller.signal,
|
||
);
|
||
await vi.waitFor(() => expect(construct).toHaveBeenCalledTimes(1));
|
||
controller.abort();
|
||
ready.resolve();
|
||
await expect(inspected).rejects.toMatchObject({ name: 'AbortError' });
|
||
expect(close).toHaveBeenCalledTimes(1);
|
||
} finally {
|
||
vi.unstubAllGlobals();
|
||
}
|
||
});
|
||
|
||
it('closes a late ImageBitmap when decode is aborted', async () => {
|
||
const bitmap = {
|
||
width: 640,
|
||
height: 480,
|
||
close: vi.fn(),
|
||
};
|
||
const pendingBitmap = createDeferred<typeof bitmap>();
|
||
vi.stubGlobal('createImageBitmap', vi.fn(() => pendingBitmap.promise));
|
||
const controller = new AbortController();
|
||
|
||
try {
|
||
const decoded = browserImageCodec.decode(
|
||
new Blob(['image'], { type: 'image/png' }),
|
||
{ imageOrientation: 'from-image' },
|
||
controller.signal,
|
||
);
|
||
controller.abort();
|
||
pendingBitmap.resolve(bitmap);
|
||
|
||
await expect(decoded).rejects.toMatchObject({ name: 'AbortError' });
|
||
expect(bitmap.close).toHaveBeenCalledTimes(1);
|
||
} finally {
|
||
vi.unstubAllGlobals();
|
||
}
|
||
});
|
||
|
||
it('revokes the fallback image URL when decode is aborted', async () => {
|
||
const createObjectURL = vi.fn(() => 'blob:pending-image');
|
||
const revokeObjectURL = vi.fn();
|
||
class PendingImage {
|
||
decoding = '';
|
||
naturalWidth = 0;
|
||
naturalHeight = 0;
|
||
onload: (() => void) | null = null;
|
||
onerror: (() => void) | null = null;
|
||
src = '';
|
||
}
|
||
vi.stubGlobal('URL', { createObjectURL, revokeObjectURL });
|
||
vi.stubGlobal('Image', PendingImage);
|
||
vi.stubGlobal('createImageBitmap', undefined);
|
||
const controller = new AbortController();
|
||
|
||
try {
|
||
const decoded = browserImageCodec.decode(
|
||
new Blob(['image'], { type: 'image/png' }),
|
||
{ imageOrientation: 'from-image' },
|
||
controller.signal,
|
||
);
|
||
controller.abort();
|
||
|
||
await expect(decoded).rejects.toMatchObject({ name: 'AbortError' });
|
||
expect(revokeObjectURL).toHaveBeenCalledTimes(1);
|
||
expect(revokeObjectURL).toHaveBeenCalledWith('blob:pending-image');
|
||
} finally {
|
||
vi.unstubAllGlobals();
|
||
}
|
||
});
|
||
|
||
it('rejects a pending canvas encoder when aborted', async () => {
|
||
let finishEncoding!: BlobCallback;
|
||
const rendered: RenderedImage = {
|
||
canvas: {
|
||
toBlob: vi.fn((callback: BlobCallback) => {
|
||
finishEncoding = callback;
|
||
}),
|
||
} as unknown as HTMLCanvasElement,
|
||
hasAlpha: false,
|
||
dispose: vi.fn(),
|
||
};
|
||
const controller = new AbortController();
|
||
const encoded = browserImageCodec.encode(
|
||
rendered,
|
||
{ mimeType: 'image/png' },
|
||
controller.signal,
|
||
);
|
||
|
||
controller.abort();
|
||
finishEncoding(new Blob(['late'], { type: 'image/png' }));
|
||
|
||
await expect(encoded).rejects.toMatchObject({ name: 'AbortError' });
|
||
});
|
||
|
||
it.each(['image/jpeg', 'image/bmp'] as const)(
|
||
'marks animation-capable bytes mislabeled as %s as unverified',
|
||
async (mimeType) => {
|
||
const staticHeader = mimeType === 'image/jpeg'
|
||
? new Uint8Array([0xff, 0xd8, 0xff])
|
||
: new Uint8Array([0x42, 0x4d]);
|
||
const webpHeader = new Uint8Array([
|
||
0x52, 0x49, 0x46, 0x46, 0, 0, 0, 0,
|
||
0x57, 0x45, 0x42, 0x50,
|
||
]);
|
||
|
||
await expect(browserImageCodec.inspectFrameCount(
|
||
new Blob([staticHeader], { type: mimeType }),
|
||
mimeType,
|
||
)).resolves.toBe(1);
|
||
await expect(browserImageCodec.inspectFrameCount(
|
||
new Blob([webpHeader], { type: mimeType }),
|
||
mimeType,
|
||
)).resolves.toBeNull();
|
||
},
|
||
);
|
||
|
||
it('closes ImageDecoder after reading a verified animated-capable raster', async () => {
|
||
const close = vi.fn();
|
||
class FakeImageDecoder {
|
||
static isTypeSupported = vi.fn(async () => true);
|
||
|
||
tracks = {
|
||
ready: Promise.resolve(),
|
||
selectedTrack: { frameCount: 2 },
|
||
};
|
||
|
||
close = close;
|
||
}
|
||
vi.stubGlobal('ImageDecoder', FakeImageDecoder);
|
||
|
||
try {
|
||
await expect(browserImageCodec.inspectFrameCount(
|
||
new Blob(['png'], { type: 'image/png' }),
|
||
'image/png',
|
||
)).resolves.toBe(2);
|
||
expect(FakeImageDecoder.isTypeSupported).toHaveBeenCalledWith('image/png');
|
||
expect(close).toHaveBeenCalledTimes(1);
|
||
} finally {
|
||
vi.unstubAllGlobals();
|
||
}
|
||
});
|
||
|
||
it('detects alpha from canvas pixels and releases the canvas allocation', () => {
|
||
const context = {
|
||
clearRect: vi.fn(),
|
||
drawImage: vi.fn(),
|
||
getImageData: vi.fn(() => ({
|
||
data: new Uint8ClampedArray([0, 0, 0, 254]),
|
||
})),
|
||
} as unknown as CanvasRenderingContext2D;
|
||
const canvas = {
|
||
width: 0,
|
||
height: 0,
|
||
getContext: vi.fn(() => context),
|
||
} as unknown as HTMLCanvasElement;
|
||
const createElement = vi.spyOn(document, 'createElement').mockReturnValue(canvas);
|
||
|
||
try {
|
||
const rendered = browserImageCodec.render({
|
||
source: {} as CanvasImageSource,
|
||
width: 2,
|
||
height: 1,
|
||
dispose: vi.fn(),
|
||
}, { width: 2, height: 1 });
|
||
|
||
expect(createElement).toHaveBeenCalledWith('canvas');
|
||
expect(rendered.hasAlpha).toBe(true);
|
||
expect(canvas.width).toBe(2);
|
||
rendered.dispose();
|
||
expect(canvas.width).toBe(1);
|
||
expect(canvas.height).toBe(1);
|
||
} finally {
|
||
createElement.mockRestore();
|
||
}
|
||
});
|
||
|
||
it('rejects an encoder result with a MIME that differs from the candidate', async () => {
|
||
const toBlob = vi.fn((callback: BlobCallback) => {
|
||
callback(new Blob(['png'], { type: 'image/png' }));
|
||
});
|
||
const rendered: RenderedImage = {
|
||
canvas: { toBlob } as unknown as HTMLCanvasElement,
|
||
hasAlpha: false,
|
||
dispose: vi.fn(),
|
||
};
|
||
|
||
await expect(browserImageCodec.encode(rendered, {
|
||
mimeType: 'image/jpeg',
|
||
quality: 0.85,
|
||
})).resolves.toBeNull();
|
||
expect(toBlob).toHaveBeenCalledWith(
|
||
expect.any(Function),
|
||
'image/jpeg',
|
||
0.85,
|
||
);
|
||
});
|
||
|
||
it('revokes the fallback image URL exactly once when Image setup throws', async () => {
|
||
const createObjectURL = vi.fn(() => 'blob:test-image');
|
||
const revokeObjectURL = vi.fn();
|
||
class ThrowingImage {
|
||
constructor() {
|
||
throw new Error('Image setup failed');
|
||
}
|
||
}
|
||
vi.stubGlobal('URL', { createObjectURL, revokeObjectURL });
|
||
vi.stubGlobal('Image', ThrowingImage);
|
||
vi.stubGlobal('createImageBitmap', undefined);
|
||
|
||
try {
|
||
await expect(browserImageCodec.decode(
|
||
new Blob(['image'], { type: 'image/png' }),
|
||
{ imageOrientation: 'from-image' },
|
||
)).rejects.toThrow('Image setup failed');
|
||
expect(revokeObjectURL).toHaveBeenCalledTimes(1);
|
||
expect(revokeObjectURL).toHaveBeenCalledWith('blob:test-image');
|
||
} finally {
|
||
vi.unstubAllGlobals();
|
||
}
|
||
});
|
||
});
|