@scality/data-browser-library 1.0.0-preview.9 → 1.0.3

package/dist/utils/__tests__/s3ConfigIdentifier.test.js

@@ -0,0 +1,437 @@
+import { computeS3ConfigIdentifier, hashSessionToken, normalizeEndpoint, normalizeRegion } from "../s3ConfigIdentifier.js";
+describe('hashSessionToken', ()=>{
+    it('should return a 16-character hex string', ()=>{
+        const hash = hashSessionToken('test-token');
+        expect(hash).toHaveLength(16);
+        expect(hash).toMatch(/^[0-9a-f]{16}$/);
+    });
+    it('should be deterministic - same input produces same output', ()=>{
+        const input = 'test-session-token';
+        const hash1 = hashSessionToken(input);
+        const hash2 = hashSessionToken(input);
+        expect(hash1).toBe(hash2);
+    });
+    it('should handle empty string', ()=>{
+        const hash = hashSessionToken('');
+        expect(hash).toHaveLength(16);
+        expect(hash).toBe('cbf29ce484222325');
+    });
+    it('should handle ASCII strings', ()=>{
+        const hash = hashSessionToken('test-session-token');
+        expect(hash).toBe('2b7823aacbaafc48');
+    });
+    it('should handle emoji and multi-byte Unicode characters', ()=>{
+        const hash1 = hashSessionToken('test🔥token');
+        const hash2 = hashSessionToken('hello-world-multibyte');
+        expect(hash1).toHaveLength(16);
+        expect(hash2).toHaveLength(16);
+        expect(hash1).not.toBe(hash2);
+    });
+    it('should handle very long strings', ()=>{
+        const longString = 'a'.repeat(10000);
+        const hash = hashSessionToken(longString);
+        expect(hash).toHaveLength(16);
+        expect(hash).toMatch(/^[0-9a-f]{16}$/);
+    });
+    it('should produce different hashes for different inputs', ()=>{
+        const hash1 = hashSessionToken('token1');
+        const hash2 = hashSessionToken('token2');
+        expect(hash1).not.toBe(hash2);
+    });
+    it('should produce different hashes for similar strings', ()=>{
+        const hash1 = hashSessionToken('test-session-token');
+        const hash2 = hashSessionToken('test-session-token1');
+        const hash3 = hashSessionToken('test-session-token2');
+        expect(hash1).not.toBe(hash2);
+        expect(hash2).not.toBe(hash3);
+        expect(hash1).not.toBe(hash3);
+    });
+    it('should handle special characters', ()=>{
+        const hash = hashSessionToken("!@#$%^&*()_+-=[]{}|;:',.<>?/~`");
+        expect(hash).toHaveLength(16);
+        expect(hash).toMatch(/^[0-9a-f]{16}$/);
+    });
+    it('should handle whitespace', ()=>{
+        const hash1 = hashSessionToken('token with spaces');
+        const hash2 = hashSessionToken('token\twith\ttabs');
+        const hash3 = hashSessionToken('token\nwith\nnewlines');
+        expect(hash1).not.toBe(hash2);
+        expect(hash2).not.toBe(hash3);
+    });
+    it('should have low collision rate for similar strings', ()=>{
+        const hashes = new Set();
+        const inputs = Array.from({
+            length: 1000
+        }, (_, i)=>`session-token-${i}`);
+        inputs.forEach((input)=>{
+            hashes.add(hashSessionToken(input));
+        });
+        expect(hashes.size).toBe(1000);
+    });
+});
+describe('normalizeRegion', ()=>{
+    it('should convert to lowercase', ()=>{
+        expect(normalizeRegion('US-EAST-1')).toBe('us-east-1');
+        expect(normalizeRegion('EU-WEST-1')).toBe('eu-west-1');
+    });
+    it('should trim whitespace', ()=>{
+        expect(normalizeRegion('  us-east-1  ')).toBe('us-east-1');
+        expect(normalizeRegion('\tus-east-1\n')).toBe('us-east-1');
+    });
+    it('should handle already normalized input', ()=>{
+        expect(normalizeRegion('us-east-1')).toBe('us-east-1');
+    });
+});
+describe('normalizeEndpoint', ()=>{
+    it('should lowercase protocol and hostname', ()=>{
+        expect(normalizeEndpoint('HTTPS://S3.AMAZONAWS.COM')).toBe('https://s3.amazonaws.com');
+    });
+    it('should remove default HTTPS port (443)', ()=>{
+        expect(normalizeEndpoint('https://s3.amazonaws.com:443')).toBe('https://s3.amazonaws.com');
+    });
+    it('should remove default HTTP port (80)', ()=>{
+        expect(normalizeEndpoint('http://localhost:80')).toBe('http://localhost');
+    });
+    it('should keep non-default ports', ()=>{
+        expect(normalizeEndpoint('http://localhost:9000')).toBe('http://localhost:9000');
+        expect(normalizeEndpoint('https://api.example.com:8443')).toBe('https://api.example.com:8443');
+    });
+    it('should remove trailing slashes', ()=>{
+        expect(normalizeEndpoint('https://s3.amazonaws.com/')).toBe('https://s3.amazonaws.com');
+        expect(normalizeEndpoint('https://s3.amazonaws.com///')).toBe('https://s3.amazonaws.com');
+    });
+    it('should preserve pathname', ()=>{
+        expect(normalizeEndpoint('https://s3.amazonaws.com/path/to/api')).toBe('https://s3.amazonaws.com/path/to/api');
+    });
+    it('should remove trailing slash from pathname', ()=>{
+        expect(normalizeEndpoint('https://s3.amazonaws.com/path/')).toBe('https://s3.amazonaws.com/path');
+    });
+    it('should normalize equivalent URLs identically', ()=>{
+        const url1 = normalizeEndpoint('HTTPS://S3.AMAZONAWS.COM:443/');
+        const url2 = normalizeEndpoint('https://s3.amazonaws.com');
+        expect(url1).toBe(url2);
+    });
+    it('should handle invalid URLs with fallback', ()=>{
+        expect(normalizeEndpoint('not-a-url')).toBe('not-a-url');
+        expect(normalizeEndpoint('ftp://example.com')).toBe('ftp://example.com');
+    });
+    it('should trim whitespace', ()=>{
+        expect(normalizeEndpoint('  https://s3.amazonaws.com  ')).toBe('https://s3.amazonaws.com');
+    });
+    it('should handle IPv6 addresses', ()=>{
+        expect(normalizeEndpoint('http://[::1]:9000')).toBe('http://[::1]:9000');
+        expect(normalizeEndpoint('http://[::1]:80')).toBe('http://[::1]');
+    });
+    it('should ignore query strings and fragments', ()=>{
+        expect(normalizeEndpoint('https://s3.amazonaws.com?query=1#frag')).toBe('https://s3.amazonaws.com');
+    });
+    it('should handle URLs with user credentials', ()=>{
+        expect(normalizeEndpoint('https://user:pass@s3.amazonaws.com')).toBe('https://s3.amazonaws.com');
+    });
+});
+describe('computeS3ConfigIdentifier', ()=>{
+    const mockConfig = (overrides = {})=>({
+            region: '',
+            endpoint: '',
+            ...overrides,
+            credentials: {
+                accessKeyId: '',
+                secretAccessKey: '',
+                ...overrides.credentials || {}
+            }
+        });
+    describe('Cache Key', ()=>{
+        it('should use cacheKey as primary identifier', ()=>{
+            const config = mockConfig({
+                cacheKey: 'my-cache-key'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('my-cache-key');
+        });
+        it('should trim cacheKey whitespace', ()=>{
+            const config = mockConfig({
+                cacheKey: '  my-cache-key  '
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('my-cache-key');
+            expect(id).not.toContain('  ');
+        });
+    });
+    describe('Access Key ID', ()=>{
+        it('should use accessKeyId', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                }
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toBe('AKIAIOSFODNN7EXAMPLE');
+        });
+        it('should trim accessKeyId whitespace', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: '  AKIAIOSFODNN7EXAMPLE  '
+                }
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toBe('AKIAIOSFODNN7EXAMPLE');
+        });
+    });
+    describe('Session Token', ()=>{
+        it('should hash session token when present', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
+                    sessionToken: 'test-session-token'
+                }
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('AKIAIOSFODNN7EXAMPLE');
+            expect(id).toContain('session:');
+            expect(id).toContain('2b7823aacbaafc48');
+        });
+        it('should not include session token if only whitespace', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
+                    sessionToken: '   '
+                }
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toBe('AKIAIOSFODNN7EXAMPLE');
+        });
+    });
+    describe('Region', ()=>{
+        it('should include region', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                region: 'us-east-1'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toBe('AKIAIOSFODNN7EXAMPLE||region:us-east-1');
+        });
+        it('should normalize region to lowercase', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                region: 'US-EAST-1'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('region:us-east-1');
+        });
+        it('should trim region whitespace', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                region: '  us-east-1  '
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('region:us-east-1');
+        });
+    });
+    describe('Endpoint', ()=>{
+        it('should normalize endpoint URL', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                endpoint: 'HTTPS://S3.AMAZONAWS.COM'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:https://s3.amazonaws.com');
+        });
+        it('should remove default HTTPS port', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                endpoint: 'https://s3.amazonaws.com:443'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:https://s3.amazonaws.com');
+            expect(id).not.toContain(':443');
+        });
+        it('should remove default HTTP port', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                endpoint: 'http://localhost:80'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:http://localhost');
+            expect(id).not.toContain(':80');
+        });
+        it('should keep non-default ports', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                endpoint: 'http://localhost:9000'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:http://localhost:9000');
+        });
+        it('should remove trailing slashes', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                endpoint: 'https://s3.amazonaws.com/'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:https://s3.amazonaws.com');
+            expect(id).not.toMatch(/\/$/);
+        });
+        it('should handle invalid URL format with fallback', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE'
+                },
+                endpoint: 'not-a-valid-url'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:not-a-valid-url');
+        });
+        it('should normalize equivalent URLs identically', ()=>{
+            const config1 = mockConfig({
+                credentials: {
+                    accessKeyId: 'KEY'
+                },
+                endpoint: 'HTTPS://S3.AMAZONAWS.COM:443/'
+            });
+            const config2 = mockConfig({
+                credentials: {
+                    accessKeyId: 'KEY'
+                },
+                endpoint: 'https://s3.amazonaws.com'
+            });
+            const id1 = computeS3ConfigIdentifier(config1);
+            const id2 = computeS3ConfigIdentifier(config2);
+            expect(id1).toBe(id2);
+        });
+        it('should preserve pathname in endpoint', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'KEY'
+                },
+                endpoint: 'https://s3.amazonaws.com/my-path/api'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:https://s3.amazonaws.com/my-path/api');
+        });
+        it('should remove trailing slash from pathname', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'KEY'
+                },
+                endpoint: 'https://s3.amazonaws.com/my-path/'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toContain('endpoint:https://s3.amazonaws.com/my-path');
+            expect(id).not.toMatch(/\/$/);
+        });
+    });
+    describe('Combined identifiers', ()=>{
+        it('should use cacheKey only when present (ignoring accessKeyId/sessionToken)', ()=>{
+            const config = mockConfig({
+                cacheKey: 'my-cache-key',
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
+                    sessionToken: 'token'
+                },
+                region: 'us-east-1',
+                endpoint: 'https://s3.amazonaws.com'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            const parts = id.split('||');
+            expect(parts).toContain('my-cache-key');
+            expect(parts).not.toContain('AKIAIOSFODNN7EXAMPLE');
+            expect(parts.some((p)=>p.startsWith('session:'))).toBe(false);
+            expect(parts).toContain('region:us-east-1');
+            expect(parts).toContain('endpoint:https://s3.amazonaws.com');
+        });
+        it('should use accessKeyId and sessionToken when no cacheKey', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
+                    sessionToken: 'token'
+                },
+                region: 'us-east-1',
+                endpoint: 'https://s3.amazonaws.com'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            const parts = id.split('||');
+            expect(parts).toContain('AKIAIOSFODNN7EXAMPLE');
+            expect(parts.some((p)=>p.startsWith('session:'))).toBe(true);
+            expect(parts).toContain('region:us-east-1');
+            expect(parts).toContain('endpoint:https://s3.amazonaws.com');
+        });
+        it('should handle cacheKey with special characters', ()=>{
+            const config = mockConfig({
+                cacheKey: 'arn:aws:iam::123456789012:role/MyRole'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toBe('arn:aws:iam::123456789012:role/MyRole');
+            const parts = id.split('||');
+            expect(parts).toHaveLength(1);
+            expect(parts[0]).toBe('arn:aws:iam::123456789012:role/MyRole');
+        });
+        it('should handle cacheKey with region and endpoint', ()=>{
+            const config = mockConfig({
+                cacheKey: 'my-cache-key',
+                region: 'us-east-1',
+                endpoint: 'https://s3.example.com:9000'
+            });
+            const id = computeS3ConfigIdentifier(config);
+            const parts = id.split('||');
+            expect(parts).toHaveLength(3);
+            expect(parts[0]).toBe('my-cache-key');
+            expect(parts[1]).toBe('region:us-east-1');
+            expect(parts[2]).toBe('endpoint:https://s3.example.com:9000');
+        });
+    });
+    describe('Fallback identifier', ()=>{
+        it('should return fallback when no config parts available', ()=>{
+            const config = mockConfig();
+            const id = computeS3ConfigIdentifier(config, 'test-fallback');
+            expect(id).toBe('test-fallback');
+        });
+        it('should use default fallback if not provided', ()=>{
+            const config = mockConfig();
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toBe('anonymous-s3-config');
+        });
+        it('should return fallback for null/undefined config', ()=>{
+            const id1 = computeS3ConfigIdentifier(null, 'fallback');
+            const id2 = computeS3ConfigIdentifier(void 0, 'fallback');
+            expect(id1).toBe('fallback');
+            expect(id2).toBe('fallback');
+        });
+    });
+    describe('Edge cases', ()=>{
+        it('should handle config with only whitespace values', ()=>{
+            const config = mockConfig({
+                credentials: {
+                    accessKeyId: '   ',
+                    sessionToken: '   '
+                },
+                region: '   ',
+                endpoint: '   '
+            });
+            const id = computeS3ConfigIdentifier(config, 'fallback');
+            expect(id).toBe('fallback');
+        });
+        it('should handle missing credentials object', ()=>{
+            const config = {
+                region: 'us-east-1'
+            };
+            const id = computeS3ConfigIdentifier(config);
+            expect(id).toBe('region:us-east-1');
+        });
+    });
+});

package/dist/utils/constants.d.ts

@@ -10,3 +10,13 @@ export declare const VEEAM_OFFICE_365 = "Veeam Backup for Microsoft 365 (v6, v7)
 export declare const VEEAM_OFFICE_365_V8 = "Veeam Backup for Microsoft 365 (v8+)";
 /** Generic identifier for Commvault */
 export declare const COMMVAULT_APPLICATION = "Commvault";
+export declare const BUCKET_ROUTES: {
+    readonly bucketPolicy: (bucketName: string) => string;
+    readonly bucketCors: (bucketName: string) => string;
+    readonly lifecycleCreate: (bucketName: string) => string;
+    readonly lifecycleEdit: (bucketName: string, ruleId: string) => string;
+    readonly replicationCreate: (bucketName: string) => string;
+    readonly replicationEdit: (bucketName: string, ruleId: string) => string;
+    readonly notificationCreate: (bucketName: string) => string;
+    readonly notificationEdit: (bucketName: string, ruleId: string) => string;
+};

package/dist/utils/constants.js

@@ -1,9 +1,19 @@
-const BUCKET_TAG_VEEAM_APPLICATION = "X-Scality-Veeam-Application";
-const BUCKET_TAG_APPLICATION = "X-Scality-Application";
-const VEEAM_BACKUP_REPLICATION = "Veeam Backup & Replication";
-const VEEAM_IMMUTABLE_POLICY_NAME = "Scality-Veeam-Immutable-Policy";
-const VEEAM_VBO_APPLICATION = "Veeam Backup for Microsoft 365";
-const VEEAM_OFFICE_365 = "Veeam Backup for Microsoft 365 (v6, v7)";
-const VEEAM_OFFICE_365_V8 = "Veeam Backup for Microsoft 365 (v8+)";
-const COMMVAULT_APPLICATION = "Commvault";
-export { BUCKET_TAG_APPLICATION, BUCKET_TAG_VEEAM_APPLICATION, COMMVAULT_APPLICATION, VEEAM_BACKUP_REPLICATION, VEEAM_IMMUTABLE_POLICY_NAME, VEEAM_OFFICE_365, VEEAM_OFFICE_365_V8, VEEAM_VBO_APPLICATION };
+const BUCKET_TAG_VEEAM_APPLICATION = 'X-Scality-Veeam-Application';
+const BUCKET_TAG_APPLICATION = 'X-Scality-Application';
+const VEEAM_BACKUP_REPLICATION = 'Veeam Backup & Replication';
+const VEEAM_IMMUTABLE_POLICY_NAME = 'Scality-Veeam-Immutable-Policy';
+const VEEAM_VBO_APPLICATION = 'Veeam Backup for Microsoft 365';
+const VEEAM_OFFICE_365 = 'Veeam Backup for Microsoft 365 (v6, v7)';
+const VEEAM_OFFICE_365_V8 = 'Veeam Backup for Microsoft 365 (v8+)';
+const COMMVAULT_APPLICATION = 'Commvault';
+const BUCKET_ROUTES = {
+    bucketPolicy: (bucketName)=>`/buckets/${bucketName}/policy`,
+    bucketCors: (bucketName)=>`/buckets/${bucketName}/cors`,
+    lifecycleCreate: (bucketName)=>`/buckets/${bucketName}/lifecycle/create`,
+    lifecycleEdit: (bucketName, ruleId)=>`/buckets/${bucketName}/lifecycle/edit/${encodeURIComponent(ruleId)}`,
+    replicationCreate: (bucketName)=>`/buckets/${bucketName}/replication/create`,
+    replicationEdit: (bucketName, ruleId)=>`/buckets/${bucketName}/replication/edit/${encodeURIComponent(ruleId)}`,
+    notificationCreate: (bucketName)=>`/buckets/${bucketName}/notifications/create`,
+    notificationEdit: (bucketName, ruleId)=>`/buckets/${bucketName}/notifications/edit/${encodeURIComponent(ruleId)}`
+};
+export { BUCKET_ROUTES, BUCKET_TAG_APPLICATION, BUCKET_TAG_VEEAM_APPLICATION, COMMVAULT_APPLICATION, VEEAM_BACKUP_REPLICATION, VEEAM_IMMUTABLE_POLICY_NAME, VEEAM_OFFICE_365, VEEAM_OFFICE_365_V8, VEEAM_VBO_APPLICATION };

package/dist/utils/deletion/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./types";
-export * from "./messages";
+export * from './messages';
+export * from './types';

package/dist/utils/deletion/index.js

@@ -1,2 +1,2 @@
-export * from "./types.js";
 export * from "./messages.js";
+export * from "./types.js";

package/dist/utils/deletion/messages.d.ts

@@ -1,4 +1,4 @@
-import { DeletionContext, DeletionResult } from "./types";
+import type { DeletionContext, DeletionResult } from './types';
 /**
  * Determines deletion behavior based on bucket versioning
  */

package/dist/utils/deletion/messages.js

@@ -1,4 +1,4 @@
-const maybePluralize = (count, word, suffix = "s", includeCount = true)=>{
+const maybePluralize = (count, word, suffix = 's', includeCount = true)=>{
     const pluralWord = 1 === count ? word : `${word}${suffix}`;
     return includeCount ? `${count} ${pluralWord}` : pluralWord;
 };
@@ -9,19 +9,19 @@ const getDeletionMessages = (context)=>{
     return createSpecificVersionDeletionResult(numberOfObjects);
 };
 const createNonVersionedDeletionResult = (numberOfObjects)=>({
-        info: `The selected ${maybePluralize(numberOfObjects, "object", "s", false)} will be permanently deleted.`,
+        info: `The selected ${maybePluralize(numberOfObjects, 'object', 's', false)} will be permanently deleted.`,
         checkboxRequired: true,
         confirmationRequired: false,
         isDeletionPossible: true
     });
 const createDefaultVersionDeletionResult = (numberOfObjects)=>({
-        info: `${1 === numberOfObjects ? "A delete marker" : "Delete markers"} will be added to the ${maybePluralize(numberOfObjects, "object", "s", false)}.`,
+        info: `${1 === numberOfObjects ? 'A delete marker' : 'Delete markers'} will be added to the ${maybePluralize(numberOfObjects, 'object', 's', false)}.`,
         checkboxRequired: false,
         confirmationRequired: false,
         isDeletionPossible: true
     });
 const createSpecificVersionDeletionResult = (numberOfObjects)=>({
-        info: `The selected ${maybePluralize(numberOfObjects, "version", "s", false)} will be permanently deleted.`,
+        info: `The selected ${maybePluralize(numberOfObjects, 'version', 's', false)} will be permanently deleted.`,
         checkboxRequired: true,
         confirmationRequired: false,
         isDeletionPossible: true

package/dist/utils/errorHandling.d.ts

@@ -1,4 +1,4 @@
-import { S3ServiceException } from "@aws-sdk/client-s3";
+import { type S3ServiceException } from '@aws-sdk/client-s3';
 /**
  * Business-level error categories for S3 operations.
  * Used to determine retry strategy and user messaging.
@@ -19,10 +19,10 @@ export declare enum ErrorCategory {
 export declare class EnhancedS3Error extends Error {
     readonly category: ErrorCategory;
     readonly statusCode?: number;
-    readonly metadata?: S3ServiceException["$metadata"];
+    readonly metadata?: S3ServiceException['$metadata'];
     readonly originalError: Error;
     readonly context?: Record<string, unknown>;
-    constructor(message: string, name: string, category: ErrorCategory, originalError: Error, statusCode?: number, metadata?: S3ServiceException["$metadata"], context?: Record<string, unknown>);
+    constructor(message: string, name: string, category: ErrorCategory, originalError: Error, statusCode?: number, metadata?: S3ServiceException['$metadata'], context?: Record<string, unknown>);
     /**
      * Determines if this error should be retried based on its category.
      * Only server errors and network issues are retryable.

package/dist/utils/errorHandling.js

@@ -38,13 +38,13 @@ function classifyByStatusCode(statusCode) {
     return statusCode >= 500 ? "SERVER_ERROR" : "UNKNOWN";
 }
 function isS3ServiceException(error) {
-    return error instanceof Error && "$metadata" in error;
+    return error instanceof Error && '$metadata' in error;
 }
 function isEnhancedS3Error(error) {
     return error instanceof EnhancedS3Error;
 }
 function createS3Error(error, context) {
-    if (error instanceof Error && "AbortError" === error.name) return new EnhancedS3Error("Operation was cancelled", "AbortError", "CANCELLATION", error, void 0, void 0, context);
+    if (error instanceof Error && 'AbortError' === error.name) return new EnhancedS3Error('Operation was cancelled', 'AbortError', "CANCELLATION", error, void 0, void 0, context);
     if (error instanceof NoSuchBucket || error instanceof NoSuchKey || error instanceof NoSuchUpload) return new EnhancedS3Error(error.message, error.name, "NOT_FOUND", error, error.$metadata?.httpStatusCode, error.$metadata, context);
     if (error instanceof InvalidRequest || error instanceof InvalidObjectState || error instanceof InvalidWriteOffset || error instanceof ObjectAlreadyInActiveTierError || error instanceof ObjectNotInActiveTierError) return new EnhancedS3Error(error.message, error.name, "CLIENT_ERROR", error, error.$metadata?.httpStatusCode, error.$metadata, context);
     if (isS3ServiceException(error)) {
@@ -52,11 +52,11 @@ function createS3Error(error, context) {
         return new EnhancedS3Error(error.message, error.name, category, error, error.$metadata?.httpStatusCode, error.$metadata, context);
     }
     if (error instanceof Error) {
-        const isNetwork = /network|connection|timeout|dns/i.test(error.message) || error.name.includes("Network") || error.name.includes("Timeout");
+        const isNetwork = /network|connection|timeout|dns/i.test(error.message) || error.name.includes('Network') || error.name.includes('Timeout');
         return new EnhancedS3Error(error.message, error.name, isNetwork ? "NETWORK_ERROR" : "UNKNOWN", error, void 0, void 0, context);
     }
-    const message = "string" == typeof error ? error : "Unknown error occurred";
-    return new EnhancedS3Error(message, "UnknownError", "UNKNOWN", new Error(message), void 0, void 0, context);
+    const message = 'string' == typeof error ? error : 'Unknown error occurred';
+    return new EnhancedS3Error(message, 'UnknownError', "UNKNOWN", new Error(message), void 0, void 0, context);
 }
 function createS3OperationError(error, operation, bucketName, objectKey) {
     const context = {
@@ -67,7 +67,7 @@ function createS3OperationError(error, operation, bucketName, objectKey) {
     };
     const enhancedError = createS3Error(error, context);
     if (!enhancedError.message.includes(operation)) {
-        const prefix = bucketName ? `${operation} failed for bucket '${bucketName}'${objectKey ? `, key '${objectKey}'` : ""}` : `${operation} failed`;
+        const prefix = bucketName ? `${operation} failed for bucket '${bucketName}'${objectKey ? `, key '${objectKey}'` : ''}` : `${operation} failed`;
         return new EnhancedS3Error(`${prefix}: ${enhancedError.message}`, enhancedError.name, enhancedError.category, enhancedError.originalError, enhancedError.statusCode, enhancedError.metadata, context);
     }
     return enhancedError;

package/dist/utils/hooks.js

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import { useLocation } from "react-router-dom";
+import { useLocation } from "react-router";
 const useQueryParams = ()=>{
     const location = useLocation();
     return useMemo(()=>new URLSearchParams(location.search), [
@@ -9,15 +9,15 @@ const useQueryParams = ()=>{
 const usePrefixWithSlash = ()=>{
     const query = useQueryParams();
     return useMemo(()=>{
-        const prefix = query.get("prefix");
-        if (!prefix) return "";
-        if (!prefix || "/" === prefix.slice(-1)) return prefix;
+        const prefix = query.get('prefix');
+        if (!prefix) return '';
+        if (!prefix || '/' === prefix.slice(-1)) return prefix;
         {
-            const prefixArr = prefix.split("/");
+            const prefixArr = prefix.split('/');
             prefixArr.pop();
-            if (!prefixArr.length) return "";
-            const joinedPrefix = prefixArr.join("/");
-            return joinedPrefix ? "/" !== joinedPrefix.slice(-1) ? `${joinedPrefix}/` : joinedPrefix : "";
+            if (!prefixArr.length) return '';
+            const joinedPrefix = prefixArr.join('/');
+            return joinedPrefix ? '/' !== joinedPrefix.slice(-1) ? `${joinedPrefix}/` : joinedPrefix : '';
         }
     }, [
         query

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
-export * from "./s3Client";
-export * from "./errorHandling";
-export * from "./constants";
-export * from "./s3RuleUtils";
+export * from './constants';
+export * from './errorHandling';
+export * from './s3Client';
+export { ANONYMOUS_S3_CONFIG_IDENTIFIER, computeS3ConfigIdentifier, hashSessionToken, type S3ConfigIdentifierConfig, } from './s3ConfigIdentifier';
+export * from './s3RuleUtils';

package/dist/utils/index.js

@@ -1,4 +1,6 @@
-export * from "./s3Client.js";
-export * from "./errorHandling.js";
+import { ANONYMOUS_S3_CONFIG_IDENTIFIER, computeS3ConfigIdentifier, hashSessionToken } from "./s3ConfigIdentifier.js";
 export * from "./constants.js";
+export * from "./errorHandling.js";
+export * from "./s3Client.js";
 export * from "./s3RuleUtils.js";
+export { ANONYMOUS_S3_CONFIG_IDENTIFIER, computeS3ConfigIdentifier, hashSessionToken };