@wordpress/upload-media
Version:
Core media upload logic.
254 lines (252 loc) • 8.48 kB
JavaScript
;
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/actions.ts
var actions_exports = {};
__export(actions_exports, {
addItems: () => addItems,
cancelItem: () => cancelItem,
executeRetry: () => executeRetry,
retryItem: () => retryItem,
scheduleRetry: () => scheduleRetry
});
module.exports = __toCommonJS(actions_exports);
var import_uuid = require("uuid");
var import_i18n = require("@wordpress/i18n");
var import_types = require("./types.cjs");
var import_retry = require("./utils/retry.cjs");
var import_utils = require("./utils/index.cjs");
var import_video_conversion = require("./utils/video-conversion.cjs");
var import_debug_logger = require("./utils/debug-logger.cjs");
var import_upload_error = require("../upload-error.cjs");
var import_validate_mime_type = require("../validate-mime-type.cjs");
var import_validate_mime_type_for_user = require("../validate-mime-type-for-user.cjs");
var import_validate_file_size = require("../validate-file-size.cjs");
function addItems({
files,
onChange,
onSuccess,
onError,
onBatchSuccess,
additionalData,
allowedTypes
}) {
return async ({ select, dispatch }) => {
const batchId = (0, import_uuid.v4)();
for (const file of files) {
try {
(0, import_validate_mime_type.validateMimeType)(file, allowedTypes);
(0, import_validate_mime_type_for_user.validateMimeTypeForUser)(
file,
select.getSettings().allowedMimeTypes
);
} catch (error) {
onError?.(error);
continue;
}
try {
(0, import_validate_file_size.validateFileSize)(
file,
select.getSettings().maxUploadFileSize
);
} catch (error) {
onError?.(error);
continue;
}
dispatch.addItem({
file,
batchId,
onChange,
onSuccess,
onBatchSuccess,
onError,
additionalData
});
}
};
}
function cancelItem(id, error, silent = false) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
(0, import_retry.clearRetryTimer)(id);
if (!silent && error && !item.parentId && !item.attachment?.id) {
const settings = select.getSettings();
const retrySettings = settings.retry;
if (retrySettings) {
const retryCount = item.retryCount ?? 0;
const maxRetries = retrySettings.maxRetryAttempts;
if ((0, import_retry.shouldRetryError)(error, retryCount, maxRetries)) {
dispatch.scheduleRetry(id, error);
return;
}
}
}
item.abortController?.abort();
await (0, import_utils.vipsCancelOperations)(id);
await (0, import_video_conversion.cancelGifToVideoOperations)(id);
if (!silent) {
const { onError } = item;
onError?.(error ?? new Error("Upload cancelled"));
if (!onError && error && !item.parentId) {
console.error("Upload cancelled", error);
}
} else {
(0, import_debug_logger.debug)(
`Item cancelled: ${item.file.name} (item ${id}): ${error instanceof Error ? error.message : error}`
);
}
const { currentOperation, parentId, batchId } = item;
dispatch({
type: import_types.Type.Cancel,
id,
error
});
dispatch.removeItem(id);
dispatch.revokeBlobUrls(id);
if (currentOperation === import_types.OperationType.ResizeCrop || currentOperation === import_types.OperationType.Rotate) {
for (const pending of select.getPendingImageProcessing()) {
dispatch.processItem(pending.id);
}
}
if (currentOperation === import_types.OperationType.Upload) {
for (const pending of select.getPendingUploads()) {
dispatch.processItem(pending.id);
}
}
if (currentOperation === import_types.OperationType.TranscodeGif) {
for (const pending of select.getPendingVideoProcessing()) {
dispatch.processItem(pending.id);
}
}
if (currentOperation === import_types.OperationType.ResizeCrop || currentOperation === import_types.OperationType.Rotate || currentOperation === import_types.OperationType.TranscodeImage) {
(0, import_utils.maybeRecycleVipsWorker)(select.getActiveImageProcessingCount());
}
if (parentId) {
const parentItem = select.getItem(parentId);
if (parentItem) {
const isOptionalCompanion = item.additionalData?.image_size === "animated_video" || item.additionalData?.image_size === "animated_video_poster";
if (select.hasPendingItemsByParentId(parentId)) {
if (parentItem.operations && parentItem.operations.length > 0) {
dispatch.processItem(parentId);
}
} else if (parentItem.subSizes && parentItem.subSizes.length > 0 || isOptionalCompanion) {
if (parentItem.operations && parentItem.operations.length > 0) {
dispatch.processItem(parentId);
}
} else {
const parentAttachmentId = parentItem.attachment?.id;
const { mediaDelete } = select.getSettings();
if (parentAttachmentId && mediaDelete) {
mediaDelete(parentAttachmentId).catch(() => {
});
}
await dispatch.cancelItem(
parentId,
new import_upload_error.UploadError({
code: error instanceof import_upload_error.UploadError && error.code || import_upload_error.ErrorCode.GENERAL,
message: error?.message || (0, import_i18n.__)("The image could not be uploaded."),
file: parentItem.file,
cause: error instanceof Error ? error : void 0
})
);
}
}
}
if (batchId && select.isBatchUploaded(batchId)) {
(0, import_debug_logger.debug)(`Batch completed: ${batchId}`);
item.onBatchSuccess?.();
}
};
}
function retryItem(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
if (!item.error) {
return;
}
dispatch({
type: import_types.Type.RetryItem,
id
});
dispatch.processItem(id);
};
}
function scheduleRetry(id, error) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item) {
return;
}
const settings = select.getSettings();
const retrySettings = settings.retry;
if (!retrySettings) {
return;
}
const currentRetryCount = item.retryCount ?? 0;
const delay = (0, import_retry.calculateRetryDelay)({
attempt: currentRetryCount + 1,
initialDelay: retrySettings.initialRetryDelayMs,
maxDelay: retrySettings.maxRetryDelayMs,
multiplier: retrySettings.backoffMultiplier,
jitter: retrySettings.retryJitter
});
const timerId = setTimeout(() => {
import_retry.retryTimers.delete(id);
dispatch.executeRetry(id);
}, delay);
import_retry.retryTimers.set(id, timerId);
dispatch({
type: import_types.Type.ScheduleRetry,
id,
error,
retryCount: currentRetryCount,
nextRetryTimestamp: Date.now() + delay
});
};
}
function executeRetry(id) {
return async ({ select, dispatch }) => {
const item = select.getItem(id);
if (!item || item.status !== import_types.ItemStatus.PendingRetry) {
return;
}
if (select.isPaused()) {
return;
}
dispatch({
type: import_types.Type.RetryItem,
id
});
dispatch.processItem(id);
};
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
addItems,
cancelItem,
executeRetry,
retryItem,
scheduleRetry
});
//# sourceMappingURL=actions.cjs.map