img-upload-kit 1.1.1 → 2.0.1

package/dist/storage.cjs

@@ -1,60 +1,123 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var fs = require('fs/promises');
-var path = require('path');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
+
+var _chunkLOSVFO56cjs = require('./chunk-LOSVFO56.cjs');
+
+
+
+var _chunkQHU7FUO4cjs = require('./chunk-QHU7FUO4.cjs');
 
 // src/storage/localFsAdapter.ts
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 function sanitizeRelativePath(inputPath) {
+  if (!inputPath || typeof inputPath !== "string") {
+    throw new Error("Invalid storage path");
+  }
+  if (inputPath.includes(":") || inputPath.includes("\0")) {
+    throw new Error("Path traversal blocked in LocalFsStorageAdapter");
+  }
   const normalized = inputPath.replace(/\\/g, "/").replace(/^\/+/, "");
-  const parts = normalized.split("/").filter((segment) => segment && segment !== "." && segment !== "..");
-  if (parts.length === 0) {
+  const rawSegments = normalized.split("/").filter(Boolean);
+  if (rawSegments.length === 0) {
     throw new Error("Invalid storage path");
   }
-  return parts.join("/");
+  for (const segment of rawSegments) {
+    if (segment === "." || segment === "..") {
+      throw new Error("Invalid storage path: path traversal blocked");
+    }
+  }
+  return rawSegments.join("/");
+}
+function assertContainedInRoot(resolvedRoot, targetPath) {
+  const relative = _path2.default.relative(resolvedRoot, targetPath);
+  if (relative.startsWith("..") || _path2.default.isAbsolute(relative)) {
+    throw new Error("Path traversal blocked in LocalFsStorageAdapter");
+  }
 }
 function createLocalFsStorageAdapter(options) {
-  const resolvedRoot = path__default.default.resolve(options.rootDir);
-  const baseUrl = (options.baseUrl ?? "/uploads").replace(/\/+$/, "");
+  const resolvedRoot = _path2.default.resolve(options.rootDir);
+  const baseUrl = (_nullishCoalesce(options.baseUrl, () => ( "/uploads"))).replace(/\/+$/, "");
   const includeBucket = options.includeBucketInPath !== false;
   const resolveDiskTarget = (bucket, relativePath) => {
     const cleanBucket = sanitizeRelativePath(bucket);
     const cleanRel = sanitizeRelativePath(relativePath);
     const subPath = includeBucket ? `${cleanBucket}/${cleanRel}` : cleanRel;
-    const diskPath = path__default.default.resolve(resolvedRoot, subPath);
-    if (!diskPath.startsWith(resolvedRoot)) {
-      throw new Error("Path traversal blocked in LocalFsStorageAdapter");
-    }
+    const diskPath = _path2.default.resolve(resolvedRoot, subPath);
+    assertContainedInRoot(resolvedRoot, diskPath);
     return { diskPath, subPath, cleanRel };
   };
   const getPublicUrl = (bucket, relativePath) => {
     const { subPath } = resolveDiskTarget(bucket, relativePath);
     return `${baseUrl}/${subPath}`;
   };
+  const parseUrl = (url) => {
+    if (!url || typeof url !== "string") return null;
+    try {
+      const cleanUrl = url.split(/[?#]/)[0];
+      const prefix = `${baseUrl}/`;
+      let subPath = null;
+      if (cleanUrl.startsWith(prefix)) {
+        subPath = cleanUrl.slice(prefix.length);
+      } else if (baseUrl.startsWith("/")) {
+        const parsed = new URL(cleanUrl, "http://localhost");
+        const isLocal = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+        const isRelative = !cleanUrl.startsWith("http://") && !cleanUrl.startsWith("https://");
+        if ((isLocal || isRelative) && parsed.pathname.startsWith(prefix)) {
+          subPath = parsed.pathname.slice(prefix.length);
+        }
+      }
+      if (!subPath) return null;
+      const decoded = decodeURIComponent(subPath).replace(/\\/g, "/").replace(/^\/+/, "");
+      if (!decoded || decoded.includes(":") || decoded.includes("\0")) {
+        return null;
+      }
+      const segments = decoded.split("/").filter(Boolean);
+      if (segments.length === 0 || segments.includes("..") || segments.includes(".")) {
+        return null;
+      }
+      const diskPath = _path2.default.resolve(resolvedRoot, ...segments);
+      const relative = _path2.default.relative(resolvedRoot, diskPath);
+      if (relative.startsWith("..") || _path2.default.isAbsolute(relative)) {
+        return null;
+      }
+      if (includeBucket) {
+        if (segments.length < 2) return null;
+        return {
+          bucket: segments[0],
+          path: segments.slice(1).join("/")
+        };
+      }
+      return { path: segments.join("/") };
+    } catch (e2) {
+      return null;
+    }
+  };
   return {
     async upload(params) {
       const { diskPath, cleanRel } = resolveDiskTarget(
         params.bucket,
         params.path
       );
-      if (params.upsert === false) {
-        try {
-          await fs__default.default.access(diskPath);
-          throw new Error(
+      await _promises2.default.mkdir(_path2.default.dirname(diskPath), { recursive: true });
+      try {
+        await _promises2.default.writeFile(
+          diskPath,
+          params.data,
+          params.upsert === false ? { flag: "wx" } : void 0
+        );
+      } catch (err) {
+        if (err.code === "EEXIST") {
+          const existsError = new Error(
             `File already exists at ${params.bucket}/${cleanRel}`
           );
-        } catch (err) {
-          if (err instanceof Error && err.message.includes("File already exists")) {
-            throw err;
-          }
+          existsError.code = "EEXIST";
+          throw existsError;
         }
+        throw err;
       }
-      await fs__default.default.mkdir(path__default.default.dirname(diskPath), { recursive: true });
-      await fs__default.default.writeFile(diskPath, params.data);
       return {
         bucket: params.bucket,
         path: cleanRel,
@@ -64,66 +127,53 @@ function createLocalFsStorageAdapter(options) {
     async delete(bucket, relativePath) {
       const { diskPath } = resolveDiskTarget(bucket, relativePath);
       try {
-        await fs__default.default.unlink(diskPath);
+        await _promises2.default.unlink(diskPath);
       } catch (err) {
         if (err.code !== "ENOENT") {
           throw err;
         }
       }
     },
+    async exists(bucket, relativePath) {
+      try {
+        const { diskPath } = resolveDiskTarget(bucket, relativePath);
+        const stat = await _promises2.default.stat(diskPath);
+        return stat.isFile();
+      } catch (e3) {
+        return false;
+      }
+    },
     getPublicUrl,
+    parseUrl,
     async deleteByUrl(url) {
-      if (!url || typeof url !== "string") return false;
+      const parsed = parseUrl(url);
+      if (!parsed) return false;
       try {
-        const cleanUrl = url.split(/[?#]/)[0];
-        const prefix = `${baseUrl}/`;
-        let subPath = null;
-        if (cleanUrl.startsWith(prefix)) {
-          subPath = cleanUrl.slice(prefix.length);
-        } else if (baseUrl.startsWith("/")) {
-          const parsed = new URL(cleanUrl, "http://localhost");
-          const isLocal = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
-          const isRelative = !cleanUrl.startsWith("http://") && !cleanUrl.startsWith("https://");
-          if ((isLocal || isRelative) && parsed.pathname.startsWith(prefix)) {
-            subPath = parsed.pathname.slice(prefix.length);
-          }
-        }
-        if (!subPath) return false;
-        const decoded = decodeURIComponent(subPath).replace(/\\/g, "/").replace(/^\/+/, "");
-        if (!decoded) return false;
-        const segments = decoded.split("/").filter(Boolean);
-        if (segments.length === 0 || segments.includes("..") || segments.includes(".")) {
-          return false;
-        }
-        const diskPath = path__default.default.resolve(resolvedRoot, ...segments);
-        const relative = path__default.default.relative(resolvedRoot, diskPath);
-        if (relative.startsWith("..") || path__default.default.isAbsolute(relative)) {
-          return false;
-        }
-        await fs__default.default.unlink(diskPath);
+        const subSegments = includeBucket && parsed.bucket ? [parsed.bucket, ...parsed.path.split("/")] : parsed.path.split("/");
+        const diskPath = _path2.default.resolve(resolvedRoot, ...subSegments);
+        assertContainedInRoot(resolvedRoot, diskPath);
+        await _promises2.default.unlink(diskPath);
         return true;
-      } catch {
+      } catch (e4) {
         return false;
       }
     },
-    async list(bucket, folder) {
+    async list(bucket, folder, listOptions) {
       const cleanBucket = sanitizeRelativePath(bucket);
       const cleanFolder = folder ? sanitizeRelativePath(folder) : "";
-      const targetDir = path__default.default.resolve(
+      const targetDir = _path2.default.resolve(
         resolvedRoot,
         includeBucket ? cleanBucket : "",
         cleanFolder
       );
-      if (!targetDir.startsWith(resolvedRoot)) {
-        throw new Error("Path traversal blocked in LocalFsStorageAdapter");
-      }
+      assertContainedInRoot(resolvedRoot, targetDir);
       try {
-        const dirEntries = await fs__default.default.readdir(targetDir, { withFileTypes: true });
+        const dirEntries = await _promises2.default.readdir(targetDir, { withFileTypes: true });
         const results = [];
         for (const entry of dirEntries) {
           if (!entry.isFile()) continue;
-          const full = path__default.default.join(targetDir, entry.name);
-          const stat = await fs__default.default.stat(full);
+          const full = _path2.default.join(targetDir, entry.name);
+          const stat = await _promises2.default.stat(full);
           results.push({
             name: entry.name,
             id: entry.name,
@@ -131,10 +181,14 @@ function createLocalFsStorageAdapter(options) {
             size: stat.size
           });
         }
-        return results;
+        const offset = _optionalChain([listOptions, 'optionalAccess', _ => _.cursor]) ? Number(listOptions.cursor) || 0 : 0;
+        const limit = _nullishCoalesce(_optionalChain([listOptions, 'optionalAccess', _2 => _2.limit]), () => ( results.length));
+        const sliced = _optionalChain([listOptions, 'optionalAccess', _3 => _3.limit]) !== void 0 || offset > 0 ? results.slice(offset, offset + limit) : results;
+        const nextCursor = _optionalChain([listOptions, 'optionalAccess', _4 => _4.limit]) !== void 0 && offset + sliced.length < results.length ? String(offset + sliced.length) : void 0;
+        return _chunkLOSVFO56cjs.toPaginatedListResult.call(void 0, sliced, nextCursor);
       } catch (err) {
         if (err.code === "ENOENT") {
-          return [];
+          return _chunkLOSVFO56cjs.toPaginatedListResult.call(void 0, []);
         }
         throw err;
       }
@@ -142,83 +196,6 @@ function createLocalFsStorageAdapter(options) {
   };
 }
 
-// src/storage/memoryAdapter.ts
-function createMemoryStorageAdapter(options = {}) {
-  const baseUrl = (options.baseUrl || "https://memory.local/uploads").replace(
-    /\/+$/,
-    ""
-  );
-  const store = /* @__PURE__ */ new Map();
-  const toKey = (bucket, path2) => `${bucket}::${path2.replace(/^\/+/, "")}`;
-  const getPublicUrl = (bucket, path2) => {
-    const cleanPath = path2.replace(/^\/+/, "");
-    return `${baseUrl}/${bucket}/${cleanPath}`;
-  };
-  return {
-    async upload(params) {
-      const cleanPath = params.path.replace(/^\/+/, "");
-      const key = toKey(params.bucket, cleanPath);
-      if (params.upsert === false && store.has(key)) {
-        throw new Error(`Object already exists at ${params.bucket}/${cleanPath}`);
-      }
-      store.set(key, {
-        bucket: params.bucket,
-        path: cleanPath,
-        data: new Uint8Array(params.data),
-        contentType: params.contentType,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        metadata: params.metadata
-      });
-      return {
-        bucket: params.bucket,
-        path: cleanPath,
-        url: getPublicUrl(params.bucket, cleanPath)
-      };
-    },
-    async delete(bucket, path2) {
-      const key = toKey(bucket, path2);
-      store.delete(key);
-    },
-    getPublicUrl,
-    async list(bucket, folder) {
-      const cleanFolder = folder ? folder.replace(/^\/+|\/+$/g, "") : "";
-      const entries = [];
-      for (const obj of store.values()) {
-        if (obj.bucket !== bucket) continue;
-        if (cleanFolder && !obj.path.startsWith(`${cleanFolder}/`)) continue;
-        const name = cleanFolder ? obj.path.slice(cleanFolder.length + 1) : obj.path;
-        entries.push({
-          name,
-          id: `${obj.bucket}/${obj.path}`,
-          createdAt: obj.createdAt,
-          size: obj.data.byteLength
-        });
-      }
-      return entries;
-    },
-    async deleteByUrl(url) {
-      const prefix = `${baseUrl}/`;
-      if (!url.startsWith(prefix)) return false;
-      const rest = url.slice(prefix.length);
-      const slashIdx = rest.indexOf("/");
-      if (slashIdx === -1) return false;
-      const bucket = rest.slice(0, slashIdx);
-      const filePath = rest.slice(slashIdx + 1);
-      const key = toKey(bucket, filePath);
-      return store.delete(key);
-    },
-    getObject(bucket, path2) {
-      return store.get(toKey(bucket, path2));
-    },
-    clear() {
-      store.clear();
-    },
-    get size() {
-      return store.size;
-    }
-  };
-}
-
 // src/storage/s3Adapter.ts
 function normalizeS3Key(rawPath) {
   const normalized = rawPath.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -231,6 +208,13 @@ function resolveTransport(options) {
   if ("putObject" in options && typeof options.putObject === "function") return options;
   throw new Error("S3StorageAdapter requires putObject/deleteObject or client/transport");
 }
+function isS3PreconditionError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  const status = _nullishCoalesce(_optionalChain([e, 'access', _5 => _5.$metadata, 'optionalAccess', _6 => _6.httpStatusCode]), () => ( Number(e.statusCode)));
+  const code = String(_nullishCoalesce(_nullishCoalesce(e.code, () => ( e.name)), () => ( ""))).toLowerCase();
+  return status === 412 || code === "preconditionfailed" || code === "eexist";
+}
 function createS3StorageAdapter(options) {
   const transport = resolveTransport(options);
   const includeBucket = options.includeBucketInUrl !== false;
@@ -243,19 +227,34 @@ function createS3StorageAdapter(options) {
   return {
     async upload(params) {
       const key = normalizeS3Key(params.path);
-      const cacheControl = params.cacheControl ?? options.cacheControl ?? (params.contentType.includes("image/avif") ? "public, max-age=31536000, immutable" : "public, max-age=2592000, must-revalidate");
+      _chunkLOSVFO56cjs.validateStorageMetadata.call(void 0, params.metadata);
+      const isImmutable = params.upsert === false && params.contentType.includes("image/avif");
+      const cacheControl = _nullishCoalesce(_nullishCoalesce(params.cacheControl, () => ( options.cacheControl)), () => ( (isImmutable ? "public, max-age=31536000, immutable" : "public, max-age=2592000, must-revalidate")));
       const metadata = params.metadata || params.contentHash ? {
-        ...params.contentHash ? { contentHash: params.contentHash } : {},
-        ...params.metadata
+        ...params.metadata,
+        ...params.contentHash ? { contentHash: params.contentHash } : {}
       } : void 0;
-      await transport.putObject({
-        Bucket: params.bucket,
-        Key: key,
-        Body: params.data,
-        ContentType: params.contentType,
-        ...cacheControl ? { CacheControl: cacheControl } : {},
-        ...metadata ? { Metadata: metadata } : {}
-      });
+      try {
+        await transport.putObject({
+          Bucket: params.bucket,
+          Key: key,
+          Body: params.data,
+          ContentType: params.contentType,
+          ...cacheControl ? { CacheControl: cacheControl } : {},
+          ...metadata ? { Metadata: metadata } : {},
+          ...params.upsert === false ? { IfNoneMatch: "*" } : {}
+        });
+      } catch (err) {
+        if (isS3PreconditionError(err)) {
+          const existsErr = new Error(
+            `Object already exists at ${params.bucket}/${key}`
+          );
+          existsErr.code = "EEXIST";
+          existsErr.statusCode = 412;
+          throw existsErr;
+        }
+        throw err;
+      }
       return {
         bucket: params.bucket,
         path: key,
@@ -265,17 +264,34 @@ function createS3StorageAdapter(options) {
     async delete(bucket, path2) {
       await transport.deleteObject({ Bucket: bucket, Key: normalizeS3Key(path2) });
     },
+    async exists(bucket, path2) {
+      const key = normalizeS3Key(path2);
+      if (transport.headObject) {
+        try {
+          await transport.headObject({ Bucket: bucket, Key: key });
+          return true;
+        } catch (e5) {
+          return false;
+        }
+      }
+      const lastSlash = key.lastIndexOf("/");
+      const folder = lastSlash > 0 ? key.slice(0, lastSlash) : void 0;
+      const targetName = lastSlash > 0 ? key.slice(lastSlash + 1) : key;
+      const listed = await this.list(bucket, folder);
+      return listed.some((item) => item.name === targetName);
+    },
     getPublicUrl,
-    async list(bucket, folder) {
+    async list(bucket, folder, listOptions) {
       const cleanFolder = folder ? normalizeS3Key(folder).replace(/\/+$/, "") : "";
       const prefix = cleanFolder ? `${cleanFolder}/` : void 0;
       const input = {
         Bucket: bucket,
         ...prefix ? { Prefix: prefix } : {},
-        MaxKeys: 1e3
+        MaxKeys: _nullishCoalesce(_optionalChain([listOptions, 'optionalAccess', _7 => _7.limit]), () => ( 1e3)),
+        ..._optionalChain([listOptions, 'optionalAccess', _8 => _8.cursor]) ? { ContinuationToken: listOptions.cursor } : {}
       };
       const output = transport.listObjects ? await transport.listObjects(input) : transport.listObjectsV2 ? await transport.listObjectsV2(input) : void 0;
-      return (output?.Contents ?? []).filter((item) => Boolean(item.Key)).map((item) => {
+      const entries = (_nullishCoalesce(_optionalChain([output, 'optionalAccess', _9 => _9.Contents]), () => ( []))).filter((item) => Boolean(item.Key)).map((item) => {
         const name = prefix && item.Key.startsWith(prefix) ? item.Key.slice(prefix.length) : item.Key;
         const createdAt = item.LastModified instanceof Date ? item.LastModified.toISOString() : item.LastModified;
         return {
@@ -285,85 +301,67 @@ function createS3StorageAdapter(options) {
           ...item.Size !== void 0 ? { size: item.Size } : {}
         };
       }).filter((entry) => entry.name.length > 0);
+      return _chunkLOSVFO56cjs.toPaginatedListResult.call(void 0, entries, _optionalChain([output, 'optionalAccess', _10 => _10.NextContinuationToken]));
     },
-    async deleteByUrl(url) {
-      if (typeof options.publicBaseUrl !== "string" || !url) return false;
+    parseUrl(url) {
+      if (typeof options.publicBaseUrl !== "string" || !url) return null;
       const prefix = `${options.publicBaseUrl.replace(/\/+$/, "")}/`;
       const cleanUrl = url.split(/[?#]/)[0];
-      if (!cleanUrl.startsWith(prefix)) return false;
+      if (!cleanUrl.startsWith(prefix)) return null;
       try {
         const rest = decodeURIComponent(cleanUrl.slice(prefix.length)).replace(/^\/+/, "");
-        if (!rest) return false;
+        if (!rest) return null;
         if (includeBucket) {
           const slashIdx = rest.indexOf("/");
-          if (slashIdx <= 0 || slashIdx === rest.length - 1) return false;
-          await transport.deleteObject({
-            Bucket: rest.slice(0, slashIdx),
-            Key: rest.slice(slashIdx + 1)
-          });
-          return true;
+          if (slashIdx <= 0 || slashIdx === rest.length - 1) return null;
+          return {
+            bucket: rest.slice(0, slashIdx),
+            path: rest.slice(slashIdx + 1)
+          };
         }
-        if (!options.defaultBucket) return false;
-        await transport.deleteObject({ Bucket: options.defaultBucket, Key: rest });
+        if (!options.defaultBucket) return null;
+        return { bucket: options.defaultBucket, path: rest };
+      } catch (e6) {
+        return null;
+      }
+    },
+    async deleteByUrl(url) {
+      const parsed = _optionalChain([this, 'access', _11 => _11.parseUrl, 'optionalCall', _12 => _12(url)]);
+      if (!parsed || !parsed.bucket) return false;
+      try {
+        await transport.deleteObject({
+          Bucket: parsed.bucket,
+          Key: parsed.path
+        });
         return true;
-      } catch {
+      } catch (e7) {
         return false;
       }
     }
   };
 }
 
-// src/storage/urlParser.ts
-var DEFAULT_PUBLIC_STORAGE_PREFIX = "/storage/v1/object/public/";
-function parsePublicStorageUrl(url, publicPrefix = DEFAULT_PUBLIC_STORAGE_PREFIX) {
-  if (!url) return null;
-  try {
-    const parsed = new URL(url, "http://localhost");
-    const pathname = parsed.pathname;
-    const prefixIndex = pathname.indexOf(publicPrefix);
-    if (prefixIndex === -1) {
-      return null;
-    }
-    const relativePath = pathname.slice(prefixIndex + publicPrefix.length).replace(/^\/+/, "");
-    const segments = relativePath.split("/").filter(Boolean);
-    if (segments.length < 2) {
-      return null;
-    }
-    const [bucket, ...pathParts] = segments;
-    const filePath = pathParts.join("/");
-    const filename = pathParts[pathParts.length - 1];
-    const lastDotIndex = filename.lastIndexOf(".");
-    const extension = lastDotIndex >= 0 ? filename.slice(lastDotIndex) : null;
-    return {
-      bucket,
-      path: filePath,
-      filename,
-      extension
-    };
-  } catch {
-    return null;
-  }
-}
-
 // src/storage/supabaseAdapter.ts
 function createSupabaseStorageAdapter(client, options = {}) {
-  const publicPrefix = options.publicUrlPrefix || DEFAULT_PUBLIC_STORAGE_PREFIX;
+  const publicPrefix = options.publicUrlPrefix || _chunkQHU7FUO4cjs.DEFAULT_PUBLIC_STORAGE_PREFIX;
   return {
     async upload(params) {
-      const cacheControl = params.cacheControl || (params.contentType.includes("image/avif") ? "public, max-age=31536000, immutable" : "public, max-age=2592000, must-revalidate");
+      _chunkLOSVFO56cjs.validateStorageMetadata.call(void 0, params.metadata);
+      const isImmutable = params.upsert === false && params.contentType.includes("image/avif");
+      const cacheControl = params.cacheControl || (isImmutable ? "public, max-age=31536000, immutable" : "public, max-age=2592000, must-revalidate");
       const { data, error } = await client.storage.from(params.bucket).upload(params.path, params.data, {
         contentType: params.contentType,
         upsert: params.upsert === void 0 ? true : params.upsert,
         cacheControl,
         metadata: {
+          ...params.metadata,
           uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          contentHash: params.contentHash || "unknown",
-          ...params.metadata
+          contentHash: params.contentHash || "unknown"
         }
       });
       if (error || !data) {
         throw new Error(
-          `Failed to upload to Supabase storage (bucket: ${params.bucket}, path: ${params.path}): ${error?.message || "Unknown error"}`
+          `Failed to upload to Supabase storage (bucket: ${params.bucket}, path: ${params.path}): ${_optionalChain([error, 'optionalAccess', _13 => _13.message]) || "Unknown error"}`
         );
       }
       const {
@@ -381,60 +379,69 @@ function createSupabaseStorageAdapter(client, options = {}) {
         throw new Error(`Failed to delete from Supabase storage: ${error.message}`);
       }
     },
+    async exists(bucket, path2) {
+      const cleanPath = path2.replace(/^\/+/, "");
+      const lastSlash = cleanPath.lastIndexOf("/");
+      const folder = lastSlash > 0 ? cleanPath.slice(0, lastSlash) : void 0;
+      const targetName = lastSlash > 0 ? cleanPath.slice(lastSlash + 1) : cleanPath;
+      const entries = await this.list(bucket, folder);
+      return entries.some((entry) => entry.name === targetName);
+    },
     getPublicUrl(bucket, path2) {
       const {
         data: { publicUrl }
       } = client.storage.from(bucket).getPublicUrl(path2);
       return publicUrl;
     },
-    async list(bucket, folder) {
+    async list(bucket, folder, listOptions) {
       const bucketClient = client.storage.from(bucket);
       if (!bucketClient.list) {
-        return [];
+        return _chunkLOSVFO56cjs.toPaginatedListResult.call(void 0, []);
       }
+      const limit = _nullishCoalesce(_optionalChain([listOptions, 'optionalAccess', _14 => _14.limit]), () => ( 1e3));
+      const offset = _optionalChain([listOptions, 'optionalAccess', _15 => _15.cursor]) ? Number(listOptions.cursor) || 0 : 0;
       const { data, error } = await bucketClient.list(folder, {
-        limit: 1e3,
+        limit,
+        ...offset > 0 ? { offset } : {},
         sortBy: { column: "created_at", order: "desc" }
       });
       if (error) {
         throw new Error(`Failed to list Supabase bucket files: ${error.message}`);
       }
-      return (data || []).filter((f) => f.id !== null).map((f) => ({
+      const entries = (data || []).filter((f) => f.id !== null).map((f) => ({
         name: f.name,
-        id: f.id ?? void 0,
-        createdAt: f.created_at ?? void 0
+        id: _nullishCoalesce(f.id, () => ( void 0)),
+        createdAt: _nullishCoalesce(f.created_at, () => ( void 0))
       }));
+      const nextCursor = _optionalChain([listOptions, 'optionalAccess', _16 => _16.limit]) !== void 0 && entries.length >= limit ? String(offset + entries.length) : void 0;
+      return _chunkLOSVFO56cjs.toPaginatedListResult.call(void 0, entries, nextCursor);
+    },
+    parseUrl(url) {
+      const info = _chunkQHU7FUO4cjs.parsePublicStorageUrl.call(void 0, url, publicPrefix);
+      if (!info) return null;
+      return { bucket: info.bucket, path: info.path };
     },
     async deleteByUrl(url) {
-      const info = parsePublicStorageUrl(url, publicPrefix);
+      const info = _chunkQHU7FUO4cjs.parsePublicStorageUrl.call(void 0, url, publicPrefix);
       if (!info) return false;
       try {
-        const targets = /* @__PURE__ */ new Set([info.path]);
-        if (info.extension?.toLowerCase() === ".avif") {
-          const basePath = info.path.slice(0, -info.extension.length);
-          targets.add(`${basePath}-blur${info.extension}`);
-          targets.add(`${basePath}-thumb${info.extension}`);
-        }
-        const { error } = await client.storage.from(info.bucket).remove([...targets]);
+        const { error } = await client.storage.from(info.bucket).remove([info.path]);
         return !error;
-      } catch {
+      } catch (e8) {
         return false;
       }
     }
   };
 }
 
-// src/storage/types.ts
-function createStorageAdapter(adapter) {
-  return adapter;
-}
 
-exports.DEFAULT_PUBLIC_STORAGE_PREFIX = DEFAULT_PUBLIC_STORAGE_PREFIX;
-exports.createLocalFsStorageAdapter = createLocalFsStorageAdapter;
-exports.createMemoryStorageAdapter = createMemoryStorageAdapter;
-exports.createS3StorageAdapter = createS3StorageAdapter;
-exports.createStorageAdapter = createStorageAdapter;
-exports.createSupabaseStorageAdapter = createSupabaseStorageAdapter;
-exports.parsePublicStorageUrl = parsePublicStorageUrl;
-//# sourceMappingURL=storage.cjs.map
+
+
+
+
+
+
+
+
+exports.DEFAULT_PUBLIC_STORAGE_PREFIX = _chunkQHU7FUO4cjs.DEFAULT_PUBLIC_STORAGE_PREFIX; exports.createLocalFsStorageAdapter = createLocalFsStorageAdapter; exports.createMemoryStorageAdapter = _chunkLOSVFO56cjs.createMemoryStorageAdapter; exports.createS3StorageAdapter = createS3StorageAdapter; exports.createStorageAdapter = _chunkLOSVFO56cjs.createStorageAdapter; exports.createSupabaseStorageAdapter = createSupabaseStorageAdapter; exports.parsePublicStorageUrl = _chunkQHU7FUO4cjs.parsePublicStorageUrl; exports.toPaginatedListResult = _chunkLOSVFO56cjs.toPaginatedListResult; exports.validateStorageMetadata = _chunkLOSVFO56cjs.validateStorageMetadata;
 //# sourceMappingURL=storage.cjs.map