@visulima/storage 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/packem_shared/is-expired-CTThU1q5.js

@@ -0,0 +1,8 @@
+const isExpired = (file) => {
+  if (!file.expiredAt) {
+    return false;
+  }
+  return Date.now() > +new Date(file.expiredAt);
+};
+
+export { isExpired as i };

package/dist/packem_shared/isRetryableError-Dycp7127.js

@@ -0,0 +1,82 @@
+const defaultRetryConfig = {
+  backoffMultiplier: 2,
+  calculateDelay: void 0,
+  initialDelay: 1e3,
+  maxDelay: 3e4,
+  maxRetries: 3,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+  shouldRetry: () => true
+};
+const calculateExponentialBackoff = (attempt, initialDelay, backoffMultiplier, maxDelay) => {
+  const delay = initialDelay * backoffMultiplier ** attempt;
+  return Math.min(delay, maxDelay);
+};
+const sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+const isRetryableError = (error, retryableStatusCodes = defaultRetryConfig.retryableStatusCodes) => {
+  if (error instanceof Error) {
+    const errorWithCode = error;
+    const errorCode = errorWithCode.code;
+    const errorName = error.name;
+    if (errorCode === "ECONNRESET" || errorCode === "ETIMEDOUT" || errorCode === "ENOTFOUND" || errorCode === "ECONNREFUSED" || errorCode === "EAI_AGAIN" || errorName === "NetworkError" || errorName === "TimeoutError") {
+      return true;
+    }
+    const errorWithMetadata = error;
+    if (errorWithMetadata.$metadata) {
+      const statusCode = errorWithMetadata.$metadata.httpStatusCode;
+      if (statusCode && retryableStatusCodes.includes(statusCode)) {
+        return true;
+      }
+      if (errorWithMetadata.$fault === "server") {
+        return true;
+      }
+    }
+    if (errorWithMetadata.statusCode && retryableStatusCodes.includes(errorWithMetadata.statusCode)) {
+      return true;
+    }
+    const { retryable } = errorWithMetadata;
+    if (retryable === true) {
+      return true;
+    }
+    if (typeof retryable === "string" && retryable === "true") {
+      return true;
+    }
+    return false;
+  }
+  return false;
+};
+const retry = async (function_, config = {}) => {
+  const {
+    backoffMultiplier = defaultRetryConfig.backoffMultiplier,
+    calculateDelay = defaultRetryConfig.calculateDelay,
+    initialDelay = defaultRetryConfig.initialDelay,
+    maxDelay = defaultRetryConfig.maxDelay,
+    maxRetries = defaultRetryConfig.maxRetries,
+    retryableStatusCodes = defaultRetryConfig.retryableStatusCodes,
+    shouldRetry = defaultRetryConfig.shouldRetry
+  } = config;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    try {
+      return await function_();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries) {
+        break;
+      }
+      const isRetryable = shouldRetry(error) || isRetryableError(error, retryableStatusCodes);
+      if (!isRetryable) {
+        throw error;
+      }
+      const delay = calculateDelay ? calculateDelay(attempt, error) : calculateExponentialBackoff(attempt, initialDelay, backoffMultiplier, maxDelay);
+      if (delay !== void 0 && delay > 0) {
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+};
+const createRetryWrapper = (config = {}) => (function_) => retry(function_, config);
+
+export { createRetryWrapper, isRetryableError, retry };

package/dist/packem_shared/isValidMediaType-BeDgiObq.js

@@ -0,0 +1,35 @@
+import mime from 'mime';
+
+const isValidMediaType = (contentType, expectedType) => {
+  if (!contentType) {
+    return false;
+  }
+  return contentType.startsWith(`${expectedType}/`);
+};
+const getFormatFromContentType = (contentType) => {
+  if (!contentType) {
+    return void 0;
+  }
+  return mime.getExtension(contentType) || void 0;
+};
+const validateMediaFile = (file, expectedType, config) => {
+  const fileSize = typeof file.size === "string" ? Number.parseInt(file.size, 10) : file.size;
+  if (config?.maxSize && fileSize > config.maxSize) {
+    throw new Error(`${expectedType} size ${fileSize} exceeds maximum allowed size ${config.maxSize}`);
+  }
+  if (!isValidMediaType(file.contentType, expectedType)) {
+    throw new Error(`File is not ${expectedType === "image" ? "an" : "a"} ${expectedType}: ${file.contentType}`);
+  }
+  const format = getFormatFromContentType(file.contentType);
+  if (config?.supportedFormats && format && !config.supportedFormats.includes(format)) {
+    throw new Error(`Unsupported ${expectedType} format: ${format}`);
+  }
+};
+const isKnownContentType = (contentType) => {
+  if (!contentType) {
+    return false;
+  }
+  return !!mime.getExtension(contentType);
+};
+
+export { getFormatFromContentType, isKnownContentType, isValidMediaType, validateMediaFile };