@tagadapay/plugin-sdk 3.1.12 → 3.1.24

package/dist/v2/core/__tests__/pathRemapping.test.js

@@ -1,776 +0,0 @@
-/**
- * Path Remapping Tests
- *
- * Comprehensive test suite for path remapping functionality including:
- * - Exact path matching
- * - Parameter matching with different names
- * - Wildcards and optional segments
- * - Edge cases and error handling
- * - SDK functions: shouldMatchRoute, getInternalPath, getPathInfo
- */
-import { match } from 'path-to-regexp';
-// Mock browser environment
-const mockWindow = {
-    location: {
-        pathname: '/',
-        hostname: 'localhost',
-        search: '',
-        href: 'http://localhost:5173/',
-    },
-    addEventListener: jest.fn(),
-    removeEventListener: jest.fn(),
-    dispatchEvent: jest.fn()
-};
-const mockDocument = {
-    querySelector: jest.fn()
-};
-const mockLocalStorage = {
-    getItem: jest.fn(),
-    setItem: jest.fn(),
-    removeItem: jest.fn(),
-    clear: jest.fn()
-};
-const mockHistory = {
-    pushState: jest.fn(),
-    replaceState: jest.fn(),
-    back: jest.fn(),
-    forward: jest.fn(),
-    go: jest.fn(),
-    length: 0,
-    scrollRestoration: 'auto',
-    state: null
-};
-// Setup global mocks
-global.window = mockWindow;
-global.document = mockDocument;
-global.localStorage = mockLocalStorage;
-global.history = mockHistory;
-describe('Path Remapping - Pattern Matching', () => {
-    describe('Exact Path Matching', () => {
-        it('should match exact paths', () => {
-            const pattern = '/hello';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            expect(matchFn('/hello')).not.toBe(false);
-            expect(matchFn('/hello/')).not.toBe(false);
-            expect(matchFn('/hello-world')).toBe(false);
-            expect(matchFn('/helloworld')).toBe(false);
-        });
-        it('should NOT match paths with additional segments', () => {
-            const pattern = '/hello';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            expect(matchFn('/hello/world')).toBe(false);
-            expect(matchFn('/hello/123')).toBe(false);
-        });
-    });
-    describe('Parameter Matching - Same Names', () => {
-        it('should match paths with single parameter', () => {
-            const pattern = '/products/:id';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            const result1 = matchFn('/products/123');
-            const result2 = matchFn('/products/abc-xyz');
-            expect(result1).not.toBe(false);
-            expect(result2).not.toBe(false);
-            if (result1 !== false) {
-                expect(result1.params).toEqual({ id: '123' });
-            }
-            if (result2 !== false) {
-                expect(result2.params).toEqual({ id: 'abc-xyz' });
-            }
-        });
-        it('should match paths with multiple parameters', () => {
-            const pattern = '/users/:userId/posts/:postId';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/users/john/posts/456');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                expect(result.params).toEqual({ userId: 'john', postId: '456' });
-            }
-        });
-    });
-    describe('Parameter Matching - Different Names', () => {
-        it('should match external pattern with different parameter names than internal', () => {
-            // External: /myremap/:param
-            // Internal: /hello-with-param/:myparam
-            // The matching only cares about the external pattern structure
-            const externalPattern = '/myremap/:param';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/myremap/test123');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                expect(result.params).toEqual({ param: 'test123' });
-                // The internal path would be /hello-with-param/:myparam
-                // The param 'test123' would be available as :myparam in the internal route
-            }
-        });
-        it('should match complex remapping scenario', () => {
-            // External: /products/:productId/reviews/:reviewId
-            // Internal: /items/:id/comments/:commentId
-            const externalPattern = '/products/:productId/reviews/:reviewId';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/products/abc123/reviews/xyz789');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                expect(result.params).toEqual({
-                    productId: 'abc123',
-                    reviewId: 'xyz789'
-                });
-            }
-        });
-    });
-    describe('Special Characters and Encoding', () => {
-        it('should handle URL-encoded characters', () => {
-            const pattern = '/products/:id';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/products/hello%20world');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                expect(result.params).toEqual({ id: 'hello world' });
-            }
-        });
-        it('should handle special characters in parameters', () => {
-            const pattern = '/users/:username';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            const result1 = matchFn('/users/john-doe');
-            const result2 = matchFn('/users/user_123');
-            const result3 = matchFn('/users/user.name');
-            expect(result1).not.toBe(false);
-            expect(result2).not.toBe(false);
-            expect(result3).not.toBe(false);
-        });
-    });
-    describe('Optional Segments', () => {
-        it('should match paths with optional segments', () => {
-            const pattern = '/users{/:id}';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            const result1 = matchFn('/users');
-            const result2 = matchFn('/users/123');
-            expect(result1).not.toBe(false);
-            expect(result2).not.toBe(false);
-            if (result2 !== false) {
-                expect(result2.params).toEqual({ id: '123' });
-            }
-        });
-        it('should match paths with multiple optional segments', () => {
-            const pattern = '/api{/:version}{/:endpoint}';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            expect(matchFn('/api')).not.toBe(false);
-            expect(matchFn('/api/v1')).not.toBe(false);
-            expect(matchFn('/api/v1/users')).not.toBe(false);
-        });
-    });
-    describe('Wildcard Matching', () => {
-        it('should match paths with wildcards', () => {
-            const pattern = '/files/*path';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            const result1 = matchFn('/files/docs');
-            const result2 = matchFn('/files/docs/readme.md');
-            const result3 = matchFn('/files/images/logo.png');
-            expect(result1).not.toBe(false);
-            expect(result2).not.toBe(false);
-            expect(result3).not.toBe(false);
-            if (result2 !== false) {
-                expect(result2.params.path).toEqual(['docs', 'readme.md']);
-            }
-        });
-    });
-    describe('Edge Cases', () => {
-        it('should NOT match when path has trailing segments', () => {
-            const pattern = '/hello';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            expect(matchFn('/hello/extra')).toBe(false);
-            expect(matchFn('/hello/extra/segments')).toBe(false);
-        });
-        it('should handle root path', () => {
-            const pattern = '/';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            expect(matchFn('/')).not.toBe(false);
-            expect(matchFn('/hello')).toBe(false);
-        });
-        it('should handle empty parameter values', () => {
-            const pattern = '/users/:id';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            // Empty parameter should not match
-            expect(matchFn('/users/')).toBe(false);
-            expect(matchFn('/users')).toBe(false);
-        });
-        it('should handle numeric parameters', () => {
-            const pattern = '/items/:id';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/items/12345');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                // Note: params are always strings
-                expect(result.params).toEqual({ id: '12345' });
-                expect(typeof result.params.id).toBe('string');
-            }
-        });
-    });
-    describe('Case Sensitivity', () => {
-        it('should be case-sensitive when option is enabled', () => {
-            const pattern = '/Hello';
-            const matchFn = match(pattern, { decode: decodeURIComponent, end: true, sensitive: true });
-            expect(matchFn('/Hello')).not.toBe(false);
-            expect(matchFn('/hello')).toBe(false);
-            expect(matchFn('/HELLO')).toBe(false);
-        });
-    });
-    describe('Real-World Scenarios', () => {
-        it('should handle e-commerce product remapping', () => {
-            // External: /p/:productSlug
-            // Internal: /products/:id
-            const externalPattern = '/p/:productSlug';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/p/awesome-product-name');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                expect(result.params).toEqual({ productSlug: 'awesome-product-name' });
-            }
-        });
-        it('should handle checkout flow remapping', () => {
-            // External: /checkout/:step
-            // Internal: /payment/:stepId
-            const externalPattern = '/checkout/:step';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            const result1 = matchFn('/checkout/shipping');
-            const result2 = matchFn('/checkout/payment');
-            const result3 = matchFn('/checkout/confirmation');
-            expect(result1).not.toBe(false);
-            expect(result2).not.toBe(false);
-            expect(result3).not.toBe(false);
-        });
-        it('should handle thank you page with order ID remapping', () => {
-            // External: /order-success/:orderId
-            // Internal: /thankyou/:id
-            const externalPattern = '/order-success/:orderId';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/order-success/ORD-123-ABC');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                expect(result.params).toEqual({ orderId: 'ORD-123-ABC' });
-            }
-        });
-        it('should NOT match wrong paths', () => {
-            const externalPattern = '/myremap/:param';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            // These should NOT match
-            expect(matchFn('/other-page')).toBe(false);
-            expect(matchFn('/myremap')).toBe(false); // Missing parameter
-            expect(matchFn('/myremapped/test')).toBe(false); // Wrong path
-            expect(matchFn('/myremap/test/extra')).toBe(false); // Extra segment
-        });
-    });
-    describe('Parameter Name Mapping Logic', () => {
-        it('should demonstrate parameter name independence', () => {
-            // The key insight: External and internal paths can have different param names
-            // The actual URL is matched against the EXTERNAL pattern
-            // The resulting params are then mapped to the INTERNAL route
-            const externalPattern = '/custom/:myParam';
-            const internalPath = '/hello/:differentParam';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/custom/value123');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                // External pattern matched, param is 'myParam'
-                expect(result.params).toEqual({ myParam: 'value123' });
-                // In the actual implementation, React Router will handle the internal route
-                // The param value 'value123' will be available as 'differentParam'
-                // This works because both routes expect a single param in the same position
-            }
-        });
-        it('should work with multiple params in different order', () => {
-            // External: /users/:userId/posts/:postId
-            // Internal: /members/:id/articles/:articleId
-            const externalPattern = '/users/:userId/posts/:postId';
-            const matchFn = match(externalPattern, { decode: decodeURIComponent, end: true });
-            const result = matchFn('/users/john/posts/article-123');
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                expect(result.params).toEqual({
-                    userId: 'john',
-                    postId: 'article-123'
-                });
-                // React Router will map these positions to the internal route params
-            }
-        });
-    });
-});
-describe('Path Remapping - Integration Tests', () => {
-    describe('Complete Remapping Flow', () => {
-        it('should simulate complete remapping from external to internal', () => {
-            const remapConfig = {
-                externalPath: '/myremap/:param',
-                internalPath: '/hello-with-param/:myparam'
-            };
-            const currentPath = '/myremap/test123';
-            // Step 1: Check if current path matches external pattern
-            const matchFn = match(remapConfig.externalPath, {
-                decode: decodeURIComponent,
-                end: true
-            });
-            const result = matchFn(currentPath);
-            // Step 2: If match, use internal path
-            expect(result).not.toBe(false);
-            if (result !== false) {
-                const shouldUseInternalPath = remapConfig.internalPath;
-                expect(shouldUseInternalPath).toBe('/hello-with-param/:myparam');
-            }
-        });
-        it('should handle no-match scenario correctly', () => {
-            const remapConfig = {
-                externalPath: '/myremap/:param',
-                internalPath: '/hello-with-param/:myparam'
-            };
-            const currentPath = '/different-path/test';
-            const matchFn = match(remapConfig.externalPath, {
-                decode: decodeURIComponent,
-                end: true
-            });
-            const result = matchFn(currentPath);
-            // Should NOT match
-            expect(result).toBe(false);
-            // Therefore, no remapping should occur
-        });
-    });
-    describe('Multiple Remap Rules (Future Feature)', () => {
-        it('should handle multiple remap configurations', () => {
-            const remapRules = [
-                { externalPath: '/products/:id', internalPath: '/items/:itemId' },
-                { externalPath: '/checkout/:step', internalPath: '/payment/:stepId' },
-                { externalPath: '/order/:orderId', internalPath: '/thankyou/:id' }
-            ];
-            const testCases = [
-                { url: '/products/123', shouldMatch: 0 },
-                { url: '/checkout/shipping', shouldMatch: 1 },
-                { url: '/order/ABC-123', shouldMatch: 2 },
-                { url: '/random/path', shouldMatch: -1 }
-            ];
-            testCases.forEach(testCase => {
-                let matchedRuleIndex = -1;
-                for (let i = 0; i < remapRules.length; i++) {
-                    const rule = remapRules[i];
-                    const matchFn = match(rule.externalPath, {
-                        decode: decodeURIComponent,
-                        end: true
-                    });
-                    const result = matchFn(testCase.url);
-                    if (result !== false) {
-                        matchedRuleIndex = i;
-                        break;
-                    }
-                }
-                expect(matchedRuleIndex).toBe(testCase.shouldMatch);
-            });
-        });
-    });
-});
-describe('SDK Functions - shouldMatchRoute, getInternalPath, getPathInfo', () => {
-    // Import SDK functions
-    let shouldMatchRoute;
-    let getInternalPath;
-    let getPathInfo;
-    beforeEach(() => {
-        // Reset mocks
-        jest.resetModules();
-        jest.clearAllMocks();
-        // Reset window location
-        mockWindow.location.pathname = '/';
-        mockWindow.location.hostname = 'localhost';
-        mockWindow.location.search = '';
-        mockWindow.location.href = 'http://localhost:5173/';
-        // Reset localStorage mock
-        mockLocalStorage.getItem.mockReturnValue(null);
-        mockDocument.querySelector.mockReturnValue(null);
-        // Dynamically import to get fresh instances
-        const pathRemapping = require('../pathRemapping');
-        shouldMatchRoute = pathRemapping.shouldMatchRoute;
-        getInternalPath = pathRemapping.getInternalPath;
-        getPathInfo = pathRemapping.getPathInfo;
-    });
-    describe('shouldMatchRoute() - No Remapping', () => {
-        it('should match exact path without remapping', () => {
-            mockWindow.location.pathname = '/hello';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            mockDocument.querySelector.mockReturnValue(null);
-            const result = shouldMatchRoute('/hello');
-            expect(result).toBe(true);
-        });
-        it('should match path with parameters', () => {
-            mockWindow.location.pathname = '/hello-with-param/test123';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            mockDocument.querySelector.mockReturnValue(null);
-            const result = shouldMatchRoute('/hello-with-param/:myparam');
-            expect(result).toBe(true);
-        });
-        it('should NOT match different paths', () => {
-            mockWindow.location.pathname = '/other-page';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            mockDocument.querySelector.mockReturnValue(null);
-            const result = shouldMatchRoute('/hello');
-            expect(result).toBe(false);
-        });
-    });
-    describe('shouldMatchRoute() - With Remapping', () => {
-        it('should match when current URL matches external pattern', () => {
-            mockWindow.location.pathname = '/myremap/test123';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/myremap/:param',
-                internalPath: '/hello-with-param/:myparam'
-            }));
-            mockDocument.querySelector.mockReturnValue(null);
-            const result = shouldMatchRoute('/hello-with-param/:myparam');
-            expect(result).toBe(true);
-        });
-        it('should NOT match when URL does not match external pattern', () => {
-            mockWindow.location.pathname = '/other-page';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/myremap/:param',
-                internalPath: '/hello-with-param/:myparam'
-            }));
-            mockDocument.querySelector.mockReturnValue(null);
-            const result = shouldMatchRoute('/hello-with-param/:myparam');
-            expect(result).toBe(false);
-        });
-    });
-    describe('Real-World Scenarios', () => {
-        it('E-commerce: Product page remapping', () => {
-            mockWindow.location.pathname = '/p/awesome-product-slug';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/p/:slug',
-                internalPath: '/products/:id'
-            }));
-            expect(getInternalPath()).toBe('/products/:id');
-            expect(shouldMatchRoute('/products/:id')).toBe(true);
-            expect(shouldMatchRoute('/hello')).toBe(false);
-        });
-        it('Checkout: Step remapping', () => {
-            mockWindow.location.pathname = '/checkout/shipping';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/checkout/:step',
-                internalPath: '/payment/:stepId'
-            }));
-            expect(getInternalPath()).toBe('/payment/:stepId');
-            expect(shouldMatchRoute('/payment/:stepId')).toBe(true);
-        });
-    });
-});
-describe('SDK Functions - matchRoute() with Parameter Extraction', () => {
-    let matchRoute;
-    beforeEach(() => {
-        // Reset mocks
-        jest.resetModules();
-        jest.clearAllMocks();
-        // Reset window location
-        mockWindow.location.pathname = '/';
-        mockWindow.location.hostname = 'localhost';
-        mockWindow.location.search = '';
-        mockWindow.location.href = 'http://localhost:5173/';
-        // Reset localStorage mock
-        mockLocalStorage.getItem.mockReturnValue(null);
-        mockDocument.querySelector.mockReturnValue(null);
-        // Dynamically import to get fresh instances
-        const pathRemapping = require('../pathRemapping');
-        matchRoute = pathRemapping.matchRoute;
-    });
-    describe('Non-Remapped Paths - Parameter Extraction', () => {
-        it('should match static path and return empty params', () => {
-            mockWindow.location.pathname = '/hello';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/hello');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({});
-        });
-        it('should extract single parameter from URL', () => {
-            mockWindow.location.pathname = '/hello-with-param/test123';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/hello-with-param/:myparam');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ myparam: 'test123' });
-        });
-        it('should extract multiple parameters from URL', () => {
-            mockWindow.location.pathname = '/users/john/posts/456';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/users/:userId/posts/:postId');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({
-                userId: 'john',
-                postId: '456'
-            });
-        });
-        it('should return no match for different path', () => {
-            mockWindow.location.pathname = '/other-page';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/hello');
-            expect(result.matched).toBe(false);
-            expect(result.params).toEqual({});
-        });
-        it('should handle URL-encoded parameters', () => {
-            mockWindow.location.pathname = '/products/hello%20world';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/products/:slug');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ slug: 'hello world' });
-        });
-    });
-    describe('Remapped Paths - Parameter Extraction (Matching Names)', () => {
-        it('should extract params from external URL with matching parameter names', () => {
-            mockWindow.location.pathname = '/myremap/test123';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/myremap/:myparam',
-                internalPath: '/hello-with-param/:myparam'
-            }));
-            const result = matchRoute('/hello-with-param/:myparam');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ myparam: 'test123' });
-        });
-        it('should extract multiple params from external URL with matching names', () => {
-            mockWindow.location.pathname = '/u/john/p/456';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/u/:userId/p/:postId',
-                internalPath: '/users/:userId/posts/:postId'
-            }));
-            const result = matchRoute('/users/:userId/posts/:postId');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({
-                userId: 'john',
-                postId: '456'
-            });
-        });
-        it('should handle complex slugs with hyphens and numbers', () => {
-            mockWindow.location.pathname = '/custom/awesome-product-123';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/custom/:slug',
-                internalPath: '/products/:slug'
-            }));
-            const result = matchRoute('/products/:slug');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ slug: 'awesome-product-123' });
-        });
-        it('should return no match when external URL does not match pattern', () => {
-            mockWindow.location.pathname = '/wrong-path/test';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/myremap/:param',
-                internalPath: '/hello-with-param/:myparam'
-            }));
-            const result = matchRoute('/hello-with-param/:myparam');
-            expect(result.matched).toBe(false);
-            expect(result.params).toEqual({});
-        });
-    });
-    describe('Remapped Paths - Production Meta Tag', () => {
-        it('should work with simple meta tag (current production format)', () => {
-            // Note: In production, meta tag only provides the internal path, not the full remap config
-            // The remapping logic would be handled by the CRM/server-side
-            mockWindow.location.pathname = '/custom/test456';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            // Mock the x-plugin-internal-path meta tag (current production format)
-            const mockMetaTag = {
-                getAttribute: jest.fn().mockReturnValue('/hello-with-param/:myparam')
-            };
-            mockDocument.querySelector.mockReturnValue(mockMetaTag);
-            const result = matchRoute('/hello-with-param/:myparam');
-            // Without localStorage config, the meta tag alone doesn't provide external pattern
-            // so params can't be extracted from the external URL
-            // This test confirms the current behavior
-            expect(result.matched).toBe(true);
-            // Params will be empty or extracted from trying to match against internal pattern
-            expect(result.params).toBeDefined();
-        });
-        it('should prioritize localStorage over meta tag', () => {
-            mockWindow.location.pathname = '/local/test789';
-            // localStorage config
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/local/:localParam',
-                internalPath: '/hello-with-param/:myparam'
-            }));
-            // Meta tag config (should be ignored)
-            const mockMetaTag = {
-                getAttribute: jest.fn().mockReturnValue(JSON.stringify({
-                    external: '/meta/:metaParam',
-                    internal: '/hello-with-param/:myparam'
-                }))
-            };
-            mockDocument.querySelector.mockReturnValue(mockMetaTag);
-            const result = matchRoute('/hello-with-param/:myparam');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ localParam: 'test789' });
-        });
-    });
-    describe('Edge Cases and Error Handling', () => {
-        it('should handle empty parameter values', () => {
-            mockWindow.location.pathname = '/hello-with-param/';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/hello-with-param/:myparam');
-            // path-to-regexp should handle this
-            expect(result.matched).toBe(false);
-        });
-        it('should handle special characters in parameters', () => {
-            mockWindow.location.pathname = '/products/test-product_123';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/products/:id');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ id: 'test-product_123' });
-        });
-        it('should return no match for malformed paths', () => {
-            mockWindow.location.pathname = '/hello//double-slash';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/hello/:param');
-            expect(result.matched).toBe(false);
-        });
-        it('should handle root path', () => {
-            mockWindow.location.pathname = '/';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({});
-        });
-        it('should throw error for invalid internal path (no leading slash)', () => {
-            mockWindow.location.pathname = '/hello';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            expect(() => {
-                matchRoute('hello');
-            }).toThrow('internalPath must start with /');
-        });
-        it('should throw error for empty internal path', () => {
-            mockWindow.location.pathname = '/hello';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            expect(() => {
-                matchRoute('');
-            }).toThrow('internalPath cannot be empty');
-        });
-    });
-    describe('Real-World E-Commerce Scenarios', () => {
-        it('Product page: Custom SEO-friendly URL → Internal product ID', () => {
-            mockWindow.location.pathname = '/p/awesome-wireless-headphones';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/p/:slug',
-                internalPath: '/products/:slug'
-            }));
-            const result = matchRoute('/products/:slug');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ slug: 'awesome-wireless-headphones' });
-        });
-        it('Checkout flow: Custom steps → Internal payment flow', () => {
-            mockWindow.location.pathname = '/checkout/billing-info';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/checkout/:step',
-                internalPath: '/payment/:step'
-            }));
-            const result = matchRoute('/payment/:step');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ step: 'billing-info' });
-        });
-        it('Thank you page: Order confirmation with custom URL', () => {
-            mockWindow.location.pathname = '/order/ORD-2024-12345';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/order/:orderId',
-                internalPath: '/thankyou/:orderId'
-            }));
-            const result = matchRoute('/thankyou/:orderId');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ orderId: 'ORD-2024-12345' });
-        });
-        it('User profile: Username in URL', () => {
-            mockWindow.location.pathname = '/user/john_doe_123';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/user/:username',
-                internalPath: '/profile/:username'
-            }));
-            const result = matchRoute('/profile/:username');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ username: 'john_doe_123' });
-        });
-        it('Blog post: SEO slug → Internal post ID structure', () => {
-            mockWindow.location.pathname = '/blog/how-to-use-path-remapping';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/blog/:slug',
-                internalPath: '/posts/:slug'
-            }));
-            const result = matchRoute('/posts/:slug');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ slug: 'how-to-use-path-remapping' });
-        });
-    });
-    describe('Complex Path Patterns', () => {
-        it('should handle nested paths with multiple segments', () => {
-            mockWindow.location.pathname = '/users/john/posts/456/comments';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/users/:userId/posts/:postId/comments');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({
-                userId: 'john',
-                postId: '456'
-            });
-        });
-        it('should handle paths with trailing slashes', () => {
-            mockWindow.location.pathname = '/hello-with-param/test123/';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/hello-with-param/:myparam');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ myparam: 'test123' });
-        });
-        it('should handle numeric IDs', () => {
-            mockWindow.location.pathname = '/products/12345';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/products/:id');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ id: '12345' });
-        });
-        it('should handle UUID-style IDs', () => {
-            mockWindow.location.pathname = '/orders/550e8400-e29b-41d4-a716-446655440000';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = matchRoute('/orders/:orderId');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({ orderId: '550e8400-e29b-41d4-a716-446655440000' });
-        });
-    });
-    describe('Concurrent Requests - Cache Behavior', () => {
-        it('should return consistent results for same path', () => {
-            mockWindow.location.pathname = '/hello-with-param/test123';
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result1 = matchRoute('/hello-with-param/:myparam');
-            const result2 = matchRoute('/hello-with-param/:myparam');
-            expect(result1).toEqual(result2);
-            expect(result1.params).toEqual({ myparam: 'test123' });
-        });
-        it('should handle different paths in same session', () => {
-            mockLocalStorage.getItem.mockReturnValue(null);
-            // First path
-            mockWindow.location.pathname = '/products/123';
-            const result1 = matchRoute('/products/:id');
-            // Second path (simulating navigation)
-            mockWindow.location.pathname = '/users/john';
-            const result2 = matchRoute('/users/:username');
-            expect(result1.matched).toBe(true);
-            expect(result1.params).toEqual({ id: '123' });
-            expect(result2.matched).toBe(true);
-            expect(result2.params).toEqual({ username: 'john' });
-        });
-    });
-    describe('Integration with CRM Validation Rules', () => {
-        it('should work with enforced matching parameter names', () => {
-            // CRM ensures external and internal params have same names
-            mockWindow.location.pathname = '/custom/test123';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/custom/:myparam',
-                internalPath: '/hello-with-param/:myparam'
-            }));
-            const result = matchRoute('/hello-with-param/:myparam');
-            expect(result.matched).toBe(true);
-            // Parameter names match, so extraction is straightforward
-            expect(result.params).toEqual({ myparam: 'test123' });
-        });
-        it('should handle multiple params with enforced naming', () => {
-            mockWindow.location.pathname = '/c/electronics/p/laptop-123';
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify({
-                externalPath: '/c/:category/p/:productId',
-                internalPath: '/shop/:category/item/:productId'
-            }));
-            const result = matchRoute('/shop/:category/item/:productId');
-            expect(result.matched).toBe(true);
-            expect(result.params).toEqual({
-                category: 'electronics',
-                productId: 'laptop-123'
-            });
-        });
-    });
-});