@wordpress/upload-media
Version:
Core media upload logic.
1,149 lines (1,147 loc) • 34.8 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// packages/upload-media/src/store/private-actions.ts
var private_actions_exports = {};
__export(private_actions_exports, {
addItem: () => addItem,
addSideloadItem: () => addSideloadItem,
detectUltraHdr: () => detectUltraHdr,
finalizeItem: () => finalizeItem,
finishOperation: () => finishOperation,
generateThumbnails: () => generateThumbnails,
getTranscodeImageOperation: () => getTranscodeImageOperation,
pauseItem: () => pauseItem,
pauseQueue: () => pauseQueue,
prepareItem: () => prepareItem,
processItem: () => processItem,
removeItem: () => removeItem,
resizeCropItem: () => resizeCropItem,
resumeQueue: () => resumeQueue,
revokeBlobUrls: () => revokeBlobUrls,
rotateItem: () => rotateItem,
sideloadItem: () => sideloadItem,
transcodeGifItem: () => transcodeGifItem,
transcodeImageItem: () => transcodeImageItem,
updateItemProgress: () => updateItemProgress,
updateSettings: () => updateSettings,
uploadItem: () => uploadItem
});
module.exports = __toCommonJS(private_actions_exports);
var import_uuid = require("uuid");
var import_blob = require("@wordpress/blob");
var import_i18n = require("@wordpress/i18n");
var import_utils = require("../utils.cjs");
var import_canvas_utils = require("../canvas-utils.cjs");
var import_heic_parser = require("../heic-parser.cjs");
var import_feature_detection = require("../feature-detection.cjs");
var import_get_image_dimensions = require("../get-image-dimensions.cjs");
var import_constants = require("./constants.cjs");
var import_stub_file = require("../stub-file.cjs");
var import_upload_error = require("../upload-error.cjs");
var import_debug_logger = require("./utils/debug-logger.cjs");
var import_utils2 = require("./utils/index.cjs");
var import_video_conversion = require("./utils/video-conversion.cjs");
var import_types = require("./types.cjs");
var import_retry = require("./utils/retry.cjs");
var DEFAULT_OUTPUT_QUALITY = 0.82;
var ultraHdrItems = /* @__PURE__ */ new Set();
function addItem({
file: fileOrBlob,
batchId,
onChange,
onSuccess,
onBatchSuccess,
onError,
additionalData = {},
sourceUrl,
sourceAttachmentId,
abortController,
operations
}) {
return async ({ dispatch }) => {
const itemId = (0, import_uuid.v4)();
const file = (0, import_utils.convertBlobToFile)(fileOrBlob);
let blobUrl;
if (!(file instanceof import_stub_file.StubFile)) {
blobUrl = (0, import_blob.createBlobURL)(file);
dispatch({
type: import_types.Type.CacheBlobUrl,
id: itemId,
blobUrl
});
}
dispatch({
type: import_types.Type.Add,
item: {
id: itemId,
batchId,
status: import_types.ItemStatus.Processing,
sourceFile: (0, import_utils.cloneFile)(file),
file,
attachment: {
url: blobUrl
},
additionalData: {
generate_sub_sizes: false,
...additionalData
},
onChange,
onSuccess,
onBatchSuccess,
onError,
sourceUrl,
sourceAttachmentId,
abortController: abortController || new AbortController(),
operations: Array.isArray(operations) ? operations : [import_types.OperationType.Prepare]
}
});
dispatch.processItem(itemId);
};
}
function addSideloadItem({
file,
onChange,
additionalData,
operations,
batchId,
parentId
}) {
return ({ dispatch }) => {
const itemId = (0, import_uuid.v4)();
dispatch({
type: import_types.Type.Add,
item: {
id: itemId,
batchId,
status: import_types.ItemStatus.Processing,
sourceFile: (0, import_utils.cloneFile)(file),
file,
onChange,
additionalData: {
...additionalData
},
parentId,
operations: Array.isArray(operations) ? operations : [import_types.OperationType.Prepare],
abortController: new AbortController()
}
});
dispatch.processItem(itemId);
};
}
function processItem(id) {
return async ({ select, dispatch }) => {
if (select.isPaused()) {
return;
}
const item = select.getItem(id);
if (!item) {
return;
}
const {
attachment,
onChange,
onSuccess,
onBatchSuccess,
batchId,
parentId
} = item;
const operation = Array.isArray(item.operations?.[0]) ? item.operations[0][0] : item.operations?.[0];
const operationArgs = Array.isArray(item.operations?.[0]) ? item.operations[0][1] : void 0;
if (operation === import_types.OperationType.Upload) {
const settings = select.getSettings();
const activeCount = select.getActiveUploadCount();
if (activeCount >= settings.maxConcurrentUploads) {
return;
}
}
if (operation === import_types.OperationType.ResizeCrop || operation === import_types.OperationType.Rotate) {
const settings = select.getSettings();
const activeCount = select.getActiveImageProcessingCount();
if (activeCount >= settings.maxConcurrentImageProcessing) {
return;
}
}
if (operation === import_types.OperationType.TranscodeGif) {
const activeCount = select.getActiveVideoProcessingCount();
if (activeCount >= 1) {
return;
}
}
if (attachment) {
const isHeicUrl = attachment.url && /\.hei[cf]$/i.test(attachment.url);
if (!isHeicUrl) {
onChange?.([attachment]);
}
}
if (!operation) {
if (parentId || !parentId && !select.hasPendingItemsByParentId(id)) {
if (attachment) {
onSuccess?.([attachment]);
}
dispatch.removeItem(id);
dispatch.revokeBlobUrls(id);
if (batchId && select.isBatchUploaded(batchId)) {
onBatchSuccess?.();
}
}
if (parentId && batchId && select.isBatchUploaded(batchId)) {
const parentItem = select.getItem(parentId);
if (!parentItem) {
return;
}
if (parentItem.operations && parentItem.operations.length > 0) {
dispatch.processItem(parentId);
return;
}
if (attachment) {
parentItem.onSuccess?.([attachment]);
}
dispatch.removeItem(parentId);
dispatch.revokeBlobUrls(parentId);
if (parentItem.batchId && select.isBatchUploaded(parentItem.batchId)) {
parentItem.onBatchSuccess?.();
}
}
return;
}
if (operation === import_types.OperationType.Finalize && select.hasPendingItemsByParentId(id)) {
return;
}
dispatch({
type: import_types.Type.OperationStart,
id,
operation
});
switch (operation) {
case import_types.OperationType.Prepare:
dispatch.prepareItem(item.id);
break;
case import_types.OperationType.ResizeCrop:
dispatch.resizeCropItem(
item.id,
operationArgs
);
break;
case import_types.OperationType.Rotate:
dispatch.rotateItem(
item.id,
operationArgs
);
break;
case import_types.OperationType.TranscodeImage:
dispatch.transcodeImageItem(
item.id,
operationArgs
);
break;
case import_types.OperationType.TranscodeGif:
dispatch.transcodeGifItem(
item.id,
operationArgs
);
break;
case import_types.OperationType.Upload:
if (item.parentId) {
dispatch.sideloadItem(id);
} else {
dispatch.uploadItem(id);
}
break;
case import_types.OperationType.ThumbnailGeneration:
dispatch.generateThumbnails(id);
break;
case import_types.OperationType.Finalize:
dispatch.finalizeItem(id);
break;
case import_types.OperationType.DetectUltraHdr:
dispatch.detectUltraHdr(id);
break;
}
};
}
function pauseQueue() {
return {
type: import_types.Type.PauseQueue
};
}
function resumeQueue() {
return async ({ select, dispatch }) => {
dispatch({
type: import_types.Type.ResumeQueue
});
for (const item of select.getAllItems()) {
if (item.status === import_types.ItemStatus.PendingRetry) {
dispatch.executeRetry(item.id);
} else {
dispatch.processItem(item.id);
}
}
};
}
function pauseItem(id) {
return async ({ dispatch }) => {
dispatch({
type: import_types.Type.PauseItem,
id
});
};
}
function removeItem(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
ultraHdrItems.delete(id);
(0, import_retry.clearRetryTimer)(id);
dispatch({
type: import_types.Type.Remove,
id
});
if (select.getAllItems().length === 0) {
(0, import_utils2.terminateVipsWorker)();
(0, import_video_conversion.terminateVideoConversionWorker)();
}
};
}
function finishOperation(id, updates) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
const previousOperation = item?.currentOperation;
dispatch({
type: import_types.Type.OperationFinish,
id,
item: updates
});
dispatch.processItem(id);
if (previousOperation === import_types.OperationType.Upload) {
const pendingUploads = select.getPendingUploads();
for (const pendingItem of pendingUploads) {
dispatch.processItem(pendingItem.id);
}
}
if (previousOperation === import_types.OperationType.ResizeCrop || previousOperation === import_types.OperationType.Rotate) {
const pendingItems = select.getPendingImageProcessing();
for (const pendingItem of pendingItems) {
dispatch.processItem(pendingItem.id);
}
}
if (previousOperation === import_types.OperationType.TranscodeGif) {
const pendingItems = select.getPendingVideoProcessing();
for (const pendingItem of pendingItems) {
dispatch.processItem(pendingItem.id);
}
}
if (previousOperation === import_types.OperationType.ResizeCrop || previousOperation === import_types.OperationType.Rotate || previousOperation === import_types.OperationType.TranscodeImage) {
(0, import_utils2.maybeRecycleVipsWorker)(select.getActiveImageProcessingCount());
}
};
}
var VALID_IMAGE_FORMATS = ["jpeg", "webp", "avif", "png", "gif"];
function isValidImageFormat(format) {
return VALID_IMAGE_FORMATS.includes(format);
}
async function getTranscodeImageOperation(file, outputMimeType, interlaced = false, quality = DEFAULT_OUTPUT_QUALITY) {
if (file.type === "image/png" && outputMimeType === "image/jpeg") {
const blobUrl = (0, import_blob.createBlobURL)(file);
try {
const hasAlpha = await (0, import_utils2.vipsHasTransparency)(blobUrl);
if (hasAlpha) {
return null;
}
} catch {
return null;
} finally {
(0, import_blob.revokeBlobURL)(blobUrl);
}
}
const formatPart = outputMimeType.split("/")[1];
if (!isValidImageFormat(formatPart)) {
return null;
}
return [
import_types.OperationType.TranscodeImage,
{
outputFormat: formatPart,
outputQuality: quality,
interlaced
}
];
}
function prepareItem(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
const { file } = item;
const operations = [];
const settings = select.getSettings();
if (file.type === "image/gif" && settings.gifConvert !== false && typeof ImageDecoder !== "undefined" && typeof VideoEncoder !== "undefined") {
let isAnimated = false;
try {
isAnimated = (0, import_utils.isAnimatedGif)(await file.arrayBuffer());
} catch {
isAnimated = false;
}
if (isAnimated) {
let hasTransparency = false;
const blobUrl = (0, import_blob.createBlobURL)(file);
try {
hasTransparency = await (0, import_utils2.vipsHasTransparency)(blobUrl);
} catch {
hasTransparency = true;
} finally {
(0, import_blob.revokeBlobURL)(blobUrl);
}
if (!hasTransparency) {
operations.push(
import_types.OperationType.Upload,
import_types.OperationType.ThumbnailGeneration,
import_types.OperationType.Finalize
);
dispatch({
type: import_types.Type.AddOperations,
id,
operations
});
dispatch.finishOperation(id, {
animatedGifFile: item.file
});
return;
}
}
}
let heicJpeg = null;
const isImage = file.type.startsWith("image/");
const isVipsSupported = import_constants.CLIENT_SIDE_SUPPORTED_MIME_TYPES.includes(
file.type
);
const isHeic = import_constants.HEIC_MIME_TYPES.includes(file.type);
let tooLargeForClient = false;
if (isImage && isVipsSupported) {
const dimensions = await (0, import_get_image_dimensions.getImageDimensions)(file);
if (dimensions && (0, import_feature_detection.exceedsClientProcessingMemory)(dimensions)) {
tooLargeForClient = true;
}
}
if (file.type === "image/jpeg" && !tooLargeForClient) {
operations.push(import_types.OperationType.DetectUltraHdr);
}
if (isImage && isVipsSupported && !tooLargeForClient) {
operations.push(
import_types.OperationType.Upload,
import_types.OperationType.ThumbnailGeneration,
import_types.OperationType.Finalize
);
} else if (isImage && isHeic) {
try {
heicJpeg = await (0, import_canvas_utils.canvasConvertToJpeg)(
file,
settings.imageQuality ?? DEFAULT_OUTPUT_QUALITY
);
} catch {
dispatch.cancelItem(
id,
new import_upload_error.UploadError({
code: import_upload_error.ErrorCode.HEIC_DECODE_ERROR,
message: "This browser cannot decode HEIC images and the server does not support them either. Please convert to JPEG before uploading.",
file
})
);
return;
}
operations.push(
import_types.OperationType.Upload,
import_types.OperationType.ThumbnailGeneration,
import_types.OperationType.Finalize
);
} else {
operations.push(import_types.OperationType.Upload);
}
dispatch({
type: import_types.Type.AddOperations,
id,
operations
});
let updates;
if (isHeic && heicJpeg) {
const vipsAvailable = (0, import_feature_detection.isClientSideMediaSupported)();
updates = {
file: heicJpeg,
sourceFile: heicJpeg,
originalHeicFile: item.file,
additionalData: {
...item.additionalData,
generate_sub_sizes: !vipsAvailable,
convert_format: true
}
};
} else if (!isVipsSupported || !isImage || tooLargeForClient) {
updates = {
additionalData: {
...item.additionalData,
generate_sub_sizes: true,
convert_format: true
}
};
} else {
updates = {
additionalData: {
...item.additionalData,
generate_sub_sizes: false
}
};
}
dispatch.finishOperation(id, updates);
};
}
function detectUltraHdr(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
let info;
try {
const buffer = await item.file.arrayBuffer();
info = await (0, import_utils2.vipsGetUltraHdrInfo)(buffer);
} catch {
}
if (info) {
ultraHdrItems.add(id);
}
dispatch.finishOperation(id, {});
};
}
function uploadItem(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
const startTime = performance.now();
let finished = false;
const finishUpload = (attachment) => {
if (finished) {
return;
}
finished = true;
(0, import_debug_logger.measure)({
measureName: `Upload ${item.file.name}`,
startTime,
tooltipText: item.file.name,
properties: [
["Item ID", item.id],
["File name", item.file.name]
]
});
dispatch.finishOperation(id, { attachment });
};
select.getSettings().mediaUpload({
filesList: [item.file],
additionalData: item.additionalData,
signal: item.abortController?.signal,
onFileChange: ([attachment]) => {
if (attachment && !(0, import_blob.isBlobURL)(attachment.url)) {
finishUpload(attachment);
}
},
onSuccess: ([attachment]) => {
finishUpload(attachment);
},
onError: (error) => {
dispatch.cancelItem(id, error);
}
});
};
}
function sideloadItem(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
const { post, ...additionalData } = item.additionalData;
const mediaSideload = select.getSettings().mediaSideload;
if (!mediaSideload) {
dispatch.finishOperation(id, {});
return;
}
const startTime = performance.now();
mediaSideload({
file: item.file,
attachmentId: post,
additionalData,
signal: item.abortController?.signal,
onSuccess: (subSize) => {
(0, import_debug_logger.measure)({
measureName: `Sideload ${item.file.name}`,
startTime,
tooltipText: item.file.name,
properties: [
["Item ID", item.id],
["File name", item.file.name]
]
});
if (item.parentId) {
dispatch({
type: import_types.Type.AccumulateSubSize,
id: item.parentId,
subSize
});
}
dispatch.finishOperation(id, {});
},
onError: (error) => {
dispatch.cancelItem(id, error);
}
});
};
}
function resizeCropItem(id, args) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
if (!args?.resize) {
dispatch.finishOperation(id, {
file: item.file
});
return;
}
const startTime = performance.now();
const addSuffix = Boolean(item.parentId);
const scaledSuffix = Boolean(args.isThresholdResize);
try {
const file = await (0, import_utils2.vipsResizeImage)(
item.id,
item.file,
args.resize,
false,
// smartCrop
addSuffix,
item.abortController?.signal,
scaledSuffix,
args.quality
);
(0, import_debug_logger.measure)({
measureName: `ResizeCrop ${item.file.name}`,
startTime,
tooltipText: item.file.name,
properties: [
["Item ID", item.id],
["File name", item.file.name]
]
});
const blobUrl = (0, import_blob.createBlobURL)(file);
dispatch({
type: import_types.Type.CacheBlobUrl,
id,
blobUrl
});
dispatch.finishOperation(id, {
file,
attachment: {
url: blobUrl
}
});
} catch (error) {
dispatch.cancelItem(
id,
new import_upload_error.UploadError({
code: import_upload_error.ErrorCode.IMAGE_TRANSCODING_ERROR,
message: (0, import_i18n.__)(
"The web server cannot generate responsive image sizes for this image. Convert it to JPEG or PNG before uploading."
),
file: item.file,
cause: error instanceof Error ? error : void 0
})
);
}
};
}
function rotateItem(id, args) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
if (!args?.orientation || args.orientation === 1) {
dispatch.finishOperation(id, {
file: item.file
});
return;
}
const startTime = performance.now();
try {
const file = await (0, import_utils2.vipsRotateImage)(
item.id,
item.file,
args.orientation,
item.abortController?.signal
);
(0, import_debug_logger.measure)({
measureName: `Rotate ${item.file.name}`,
startTime,
tooltipText: item.file.name,
properties: [
["Item ID", item.id],
["File name", item.file.name]
]
});
const blobUrl = (0, import_blob.createBlobURL)(file);
dispatch({
type: import_types.Type.CacheBlobUrl,
id,
blobUrl
});
dispatch.finishOperation(id, {
file,
attachment: {
url: blobUrl
}
});
} catch (error) {
dispatch.cancelItem(
id,
new import_upload_error.UploadError({
code: import_upload_error.ErrorCode.IMAGE_ROTATION_ERROR,
message: (0, import_i18n.__)(
"The web server cannot generate responsive image sizes for this image. Convert it to JPEG or PNG before uploading."
),
file: item.file,
cause: error instanceof Error ? error : void 0
})
);
}
};
}
function transcodeImageItem(id, args) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
if (!args?.outputFormat) {
dispatch.finishOperation(id, {
file: item.file
});
return;
}
const startTime = performance.now();
const outputMimeType = `image/${args.outputFormat}`;
const quality = args.outputQuality ?? DEFAULT_OUTPUT_QUALITY;
const interlaced = args.interlaced ?? false;
try {
const file = await (0, import_utils2.vipsConvertImageFormat)(
item.id,
item.file,
outputMimeType,
quality,
interlaced
);
(0, import_debug_logger.measure)({
measureName: `Transcode ${item.file.name}`,
startTime,
tooltipText: item.file.name,
properties: [
["Item ID", item.id],
["File name", item.file.name]
]
});
const blobUrl = (0, import_blob.createBlobURL)(file);
dispatch({
type: import_types.Type.CacheBlobUrl,
id,
blobUrl
});
dispatch.finishOperation(id, {
file,
attachment: {
url: blobUrl
}
});
} catch (error) {
dispatch.cancelItem(
id,
new import_upload_error.UploadError({
code: import_upload_error.ErrorCode.MEDIA_TRANSCODING_ERROR,
message: "Image could not be transcoded to the target format",
file: item.file,
cause: error instanceof Error ? error : void 0
})
);
}
};
}
function transcodeGifItem(id, args) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
const outputFormat = args?.outputFormat ?? "mp4";
const outputMimeType = `video/${outputFormat}`;
const gifFile = item.file;
try {
const file = await (0, import_video_conversion.convertGifToVideo)(
item.id,
gifFile,
outputMimeType
);
dispatch.finishOperation(id, { file });
dispatch.addSideloadItem({
file: gifFile,
batchId: (0, import_uuid.v4)(),
parentId: item.parentId,
additionalData: {
post: item.additionalData?.post,
image_size: "animated_video_poster",
convert_format: false
},
operations: [
[
import_types.OperationType.TranscodeImage,
{
outputFormat: "jpeg",
outputQuality: DEFAULT_OUTPUT_QUALITY,
interlaced: false
}
],
import_types.OperationType.Upload
]
});
} catch (error) {
if ((0, import_video_conversion.isUnsupportedConversionError)(error)) {
dispatch.cancelItem(
id,
new Error("Animated GIF conversion unsupported"),
true
);
return;
}
console.error(
"[video-conversion] GIF to video conversion failed:",
error
);
dispatch.cancelItem(
id,
new import_upload_error.UploadError({
code: import_upload_error.ErrorCode.GIF_TRANSCODING_ERROR,
message: "Animated GIF could not be converted to video",
file: item.file,
cause: error instanceof Error ? error : void 0
}),
true
);
}
};
}
function generateThumbnails(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
if (!item.attachment) {
dispatch.finishOperation(id, {});
return;
}
const attachment = item.attachment;
const settings = select.getSettings();
if (item.originalHeicFile && attachment.id) {
dispatch.addSideloadItem({
file: item.originalHeicFile,
batchId: (0, import_uuid.v4)(),
parentId: item.id,
additionalData: {
post: attachment.id,
image_size: "source_original",
convert_format: false
},
operations: [import_types.OperationType.Upload]
});
}
if (item.animatedGifFile && attachment.id) {
const outputFormat = settings.videoOutputFormat === "video/webm" ? "webm" : "mp4";
dispatch.addSideloadItem({
file: item.animatedGifFile,
batchId: (0, import_uuid.v4)(),
parentId: item.id,
additionalData: {
post: attachment.id,
image_size: "animated_video",
convert_format: false
},
operations: [
[
import_types.OperationType.TranscodeGif,
{
outputFormat
}
],
import_types.OperationType.Upload
]
});
}
let exifOrientation = attachment.exif_orientation || 1;
const sourceType = item.sourceFile.type;
const isHeifFamily = sourceType === "image/avif" || sourceType === "image/heif";
let needsClientRotation = false;
if (isHeifFamily) {
exifOrientation = (0, import_heic_parser.getUnappliedExifOrientation)(
await item.sourceFile.arrayBuffer()
);
needsClientRotation = exifOrientation !== 1;
}
let rotatedSource;
{
const needsRotation = exifOrientation !== 1 && !item.file.name.includes("-scaled");
if ((needsRotation || needsClientRotation) && attachment.id) {
try {
rotatedSource = await (0, import_utils2.vipsRotateImage)(
item.id,
item.sourceFile,
exifOrientation,
item.abortController?.signal
);
} catch {
console.warn(
"Failed to rotate image, continuing with thumbnails"
);
}
}
if (needsRotation && rotatedSource && attachment.id) {
dispatch.addSideloadItem({
file: rotatedSource,
batchId: (0, import_uuid.v4)(),
parentId: item.id,
additionalData: {
post: attachment.id,
image_size: "original",
convert_format: false
},
operations: [import_types.OperationType.Upload]
});
}
}
if (!item.parentId && attachment.missing_image_sizes && attachment.missing_image_sizes.length > 0) {
const allImageSizes = settings.allImageSizes || {};
const sizesToGenerate = attachment.missing_image_sizes;
const thumbnailSource = needsClientRotation && rotatedSource ? rotatedSource : item.sourceFile;
const file = attachment.filename ? (0, import_utils.renameFile)(thumbnailSource, attachment.filename) : thumbnailSource;
const batchId = (0, import_uuid.v4)();
const isUltraHdr = ultraHdrItems.has(item.id);
const outputMimeType = attachment.image_output_format;
const interlaced = attachment.image_save_progressive ?? false;
const imageQuality = attachment.image_quality;
const fallbackQuality = settings.imageQuality ?? DEFAULT_OUTPUT_QUALITY;
const defaultQuality = typeof imageQuality?.default === "number" ? imageQuality.default / 100 : fallbackQuality;
const qualityForSize = (sizeName) => {
const sized = imageQuality?.sizes?.[sizeName];
if (typeof sized === "number") {
return sized / 100;
}
return defaultQuality;
};
let thumbnailTranscodeOperation = null;
if (!isUltraHdr && outputMimeType) {
thumbnailTranscodeOperation = await getTranscodeImageOperation(
thumbnailSource,
outputMimeType,
interlaced,
defaultQuality
);
}
const dimensionGroups = /* @__PURE__ */ new Map();
for (const name of sizesToGenerate) {
const imageSize = allImageSizes[name];
if (!imageSize) {
console.warn(
`Image size "${name}" not found in configuration`
);
continue;
}
const key = `${imageSize.width}x${imageSize.height}x${imageSize.crop}`;
const group = dimensionGroups.get(key);
if (group) {
group.push(name);
} else {
dimensionGroups.set(key, [name]);
}
}
for (const [, names] of dimensionGroups) {
const imageSize = allImageSizes[names[0]];
const sizeQuality = qualityForSize(names[0]);
const thumbnailOperations = [
[
import_types.OperationType.ResizeCrop,
{ resize: imageSize, quality: sizeQuality }
]
];
if (!isUltraHdr && thumbnailTranscodeOperation) {
thumbnailOperations.push([
thumbnailTranscodeOperation[0],
{
...thumbnailTranscodeOperation[1],
outputQuality: sizeQuality
}
]);
}
thumbnailOperations.push(import_types.OperationType.Upload);
const imageSizeParam = names.length === 1 ? names[0] : names;
dispatch.addSideloadItem({
file,
batchId,
parentId: item.id,
additionalData: {
// Sideloading does not use the parent post ID but the
// attachment ID as the image sizes need to be added to it.
post: attachment.id,
image_size: imageSizeParam,
convert_format: false
},
operations: thumbnailOperations
});
}
{
const { bigImageSizeThreshold } = settings;
if (bigImageSizeThreshold && attachment.id) {
const bitmap = await createImageBitmap(thumbnailSource);
const needsScaling = bitmap.width > bigImageSizeThreshold || bitmap.height > bigImageSizeThreshold;
bitmap.close();
if (needsScaling) {
const sourceForScaled = attachment.filename ? (0, import_utils.renameFile)(thumbnailSource, attachment.filename) : thumbnailSource;
const scaledOperations = [
[
import_types.OperationType.ResizeCrop,
{
resize: {
width: bigImageSizeThreshold,
height: bigImageSizeThreshold
},
isThresholdResize: true,
quality: defaultQuality
}
]
];
if (!isUltraHdr && thumbnailTranscodeOperation) {
scaledOperations.push(
thumbnailTranscodeOperation
);
}
scaledOperations.push(import_types.OperationType.Upload);
dispatch.addSideloadItem({
file: sourceForScaled,
batchId,
parentId: item.id,
additionalData: {
post: attachment.id,
image_size: "scaled",
convert_format: false
},
operations: scaledOperations
});
}
}
}
}
dispatch.finishOperation(id, {});
};
}
function finalizeItem(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
const attachment = item.attachment;
const { mediaFinalize } = select.getSettings();
const updates = {};
if (attachment?.id && mediaFinalize) {
try {
const updatedAttachment = await mediaFinalize(
attachment.id,
item.subSizes || []
);
if (updatedAttachment) {
updates.attachment = updatedAttachment;
}
} catch (error) {
console.warn("Media finalization failed:", error);
}
}
dispatch.finishOperation(id, updates);
};
}
function revokeBlobUrls(id) {
return async ({ select, dispatch }) => {
const blobUrls = select.getBlobUrls(id);
for (const blobUrl of blobUrls) {
(0, import_blob.revokeBlobURL)(blobUrl);
}
dispatch({
type: import_types.Type.RevokeBlobUrls,
id
});
};
}
function updateItemProgress(id, progress) {
return async ({ dispatch }) => {
dispatch({
type: import_types.Type.UpdateProgress,
id,
progress
});
};
}
function updateSettings(settings) {
return {
type: import_types.Type.UpdateSettings,
settings
};
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
addItem,
addSideloadItem,
detectUltraHdr,
finalizeItem,
finishOperation,
generateThumbnails,
getTranscodeImageOperation,
pauseItem,
pauseQueue,
prepareItem,
processItem,
removeItem,
resizeCropItem,
resumeQueue,
revokeBlobUrls,
rotateItem,
sideloadItem,
transcodeGifItem,
transcodeImageItem,
updateItemProgress,
updateSettings,
uploadItem
});
//# sourceMappingURL=private-actions.cjs.map