@memberjunction/react-runtime 4.1.0 → 4.3.0

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@memberjunction/react-runtime",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "description": "Platform-agnostic React component runtime for MemberJunction. Provides core compilation, registry, and execution capabilities for React components in any JavaScript environment.",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "npm run build:node && npm run build:umd",
     "build:node": "tsc",
-    "build:umd": "webpack --config webpack.umd.config.js",
+    "build:umd": "webpack --config webpack.umd.config.cjs",
     "build:clean": "rimraf ./dist && npm run build",
     "watch": "tsc -w",
     "patchVersion": "npm version patch",
-    "test": "jest"
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "memberjunction",
@@ -27,18 +29,18 @@
   },
   "homepage": "https://github.com/MemberJunction/MJ#readme",
   "dependencies": {
-    "@memberjunction/core": "4.1.0",
-    "@memberjunction/global": "4.1.0",
-    "@memberjunction/interactive-component-types": "4.1.0",
-    "@memberjunction/core-entities": "4.1.0",
-    "@memberjunction/graphql-dataprovider": "4.1.0",
+    "@memberjunction/core": "4.3.0",
+    "@memberjunction/global": "4.3.0",
+    "@memberjunction/interactive-component-types": "4.3.0",
+    "@memberjunction/core-entities": "4.3.0",
+    "@memberjunction/graphql-dataprovider": "4.3.0",
     "@babel/standalone": "^7.29.1",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
     "@types/node": "24.10.11",
-    "jest": "^30.2.0",
     "rimraf": "^6.1.2",
+    "vitest": "^4.0.18",
     "typescript": "~5.9.3",
     "webpack": "^5.105.0",
     "webpack-cli": "^6.0.1",

package/src/__tests__/cache-manager.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock window for timer functions
+const mockSetInterval = vi.fn().mockReturnValue(1);
+const mockClearInterval = vi.fn();
+vi.stubGlobal('window', {
+  setInterval: mockSetInterval,
+  clearInterval: mockClearInterval,
+});
+
+import { CacheManager } from '../utilities/cache-manager';
+
+describe('CacheManager', () => {
+  let cache: CacheManager<string>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockSetInterval.mockClear();
+    mockClearInterval.mockClear();
+    cache = new CacheManager<string>({
+      maxSize: 5,
+      defaultTTL: 10000, // 10 seconds
+      cleanupInterval: 0, // disable auto cleanup for most tests
+    });
+  });
+
+  afterEach(() => {
+    cache.destroy();
+    vi.useRealTimers();
+  });
+
+  describe('set and get', () => {
+    it('should store and retrieve a value', () => {
+      cache.set('key1', 'value1');
+      expect(cache.get('key1')).toBe('value1');
+    });
+
+    it('should return undefined for missing key', () => {
+      expect(cache.get('nonexistent')).toBeUndefined();
+    });
+
+    it('should overwrite existing value', () => {
+      cache.set('key1', 'value1');
+      cache.set('key1', 'value2');
+      expect(cache.get('key1')).toBe('value2');
+    });
+  });
+
+  describe('has', () => {
+    it('should return true for existing key', () => {
+      cache.set('key1', 'value1');
+      expect(cache.has('key1')).toBe(true);
+    });
+
+    it('should return false for missing key', () => {
+      expect(cache.has('nonexistent')).toBe(false);
+    });
+  });
+
+  describe('delete', () => {
+    it('should remove a key', () => {
+      cache.set('key1', 'value1');
+      expect(cache.delete('key1')).toBe(true);
+      expect(cache.get('key1')).toBeUndefined();
+    });
+
+    it('should return false for non-existent key', () => {
+      expect(cache.delete('nonexistent')).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    it('should remove all entries', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      cache.clear();
+      expect(cache.get('key1')).toBeUndefined();
+      expect(cache.get('key2')).toBeUndefined();
+    });
+
+    it('should reset memory usage', () => {
+      cache.set('key1', 'value1');
+      cache.clear();
+      const stats = cache.getStats();
+      expect(stats.size).toBe(0);
+      expect(stats.memoryUsage).toBe(0);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return cache statistics', () => {
+      cache.set('key1', 'value1');
+      const stats = cache.getStats();
+      expect(stats.size).toBe(1);
+      expect(stats.maxSize).toBe(5);
+      expect(stats.memoryUsage).toBeGreaterThan(0);
+    });
+  });
+
+  describe('TTL expiration', () => {
+    it('should return undefined for expired entries on get', () => {
+      cache.set('key1', 'value1');
+      vi.advanceTimersByTime(11000); // advance past 10s TTL
+      expect(cache.get('key1')).toBeUndefined();
+    });
+
+    it('should report false for expired entries on has', () => {
+      cache.set('key1', 'value1');
+      vi.advanceTimersByTime(11000);
+      expect(cache.has('key1')).toBe(false);
+    });
+  });
+
+  describe('LRU eviction', () => {
+    it('should evict oldest entry when max size reached', () => {
+      // Fill to capacity (maxSize = 5)
+      for (let i = 0; i < 5; i++) {
+        cache.set(`key${i}`, `value${i}`);
+        vi.advanceTimersByTime(100); // separate timestamps
+      }
+
+      // Adding one more should evict the oldest (key0)
+      cache.set('key5', 'value5');
+
+      // key0 should be evicted
+      expect(cache.has('key0')).toBe(false);
+      // newest should be present
+      expect(cache.get('key5')).toBe('value5');
+    });
+  });
+
+  describe('cleanup', () => {
+    it('should remove expired entries that scheduled timeout has not yet removed', () => {
+      // When set() is called, it schedules a setTimeout for TTL deletion.
+      // With fake timers, advancing time triggers those scheduled removals.
+      // After the TTL, entries are already removed by their scheduled timeouts.
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      expect(cache.getStats().size).toBe(2);
+      // Advance time past TTL -- the scheduled timeouts will fire and remove entries
+      vi.advanceTimersByTime(11000);
+      // Entries already removed by scheduled timeout, so cleanup finds nothing
+      const removed = cache.cleanup();
+      expect(removed).toBe(0);
+      expect(cache.getStats().size).toBe(0);
+    });
+
+    it('should return 0 when nothing to clean', () => {
+      cache.set('key1', 'value1');
+      const removed = cache.cleanup();
+      expect(removed).toBe(0);
+    });
+  });
+
+  describe('destroy', () => {
+    it('should clear the cache and stop timers', () => {
+      cache.set('key1', 'value1');
+      cache.destroy();
+      expect(cache.getStats().size).toBe(0);
+    });
+  });
+});

package/src/__tests__/component-error-analyzer.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest';
+
+import { ComponentErrorAnalyzer } from '../utilities/component-error-analyzer';
+
+describe('ComponentErrorAnalyzer', () => {
+  describe('identifyFailedComponents', () => {
+    it('should return empty array for empty errors', () => {
+      expect(ComponentErrorAnalyzer.identifyFailedComponents([])).toEqual([]);
+    });
+
+    it('should identify component from ReferenceError', () => {
+      const errors = ['ReferenceError: MyComponent is not defined'];
+      const result = ComponentErrorAnalyzer.identifyFailedComponents(errors);
+      expect(result).toContain('MyComponent');
+    });
+
+    it('should identify component from render error', () => {
+      const errors = ['MyWidget(...): Nothing was returned from render'];
+      const result = ComponentErrorAnalyzer.identifyFailedComponents(errors);
+      expect(result).toContain('MyWidget');
+    });
+
+    it('should identify component from not-a-function error', () => {
+      const errors = ['SomeComponent is not a function'];
+      const result = ComponentErrorAnalyzer.identifyFailedComponents(errors);
+      expect(result).toContain('SomeComponent');
+    });
+
+    it('should not identify JavaScript builtins as components', () => {
+      const errors = ['ReferenceError: Object is not defined'];
+      const result = ComponentErrorAnalyzer.identifyFailedComponents(errors);
+      expect(result).not.toContain('Object');
+    });
+
+    it('should not identify hooks as components', () => {
+      const errors = ['ReferenceError: useState is not defined'];
+      const result = ComponentErrorAnalyzer.identifyFailedComponents(errors);
+      expect(result).not.toContain('useState');
+    });
+
+    it('should deduplicate component names', () => {
+      const errors = [
+        'ReferenceError: MyComponent is not defined',
+        'MyComponent is not a function',
+      ];
+      const result = ComponentErrorAnalyzer.identifyFailedComponents(errors);
+      const uniqueCount = result.filter(c => c === 'MyComponent').length;
+      expect(uniqueCount).toBe(1);
+    });
+  });
+
+  describe('analyzeComponentErrors', () => {
+    it('should return empty array for no errors', () => {
+      expect(ComponentErrorAnalyzer.analyzeComponentErrors([])).toEqual([]);
+    });
+
+    it('should return detailed failure info for ReferenceError', () => {
+      const errors = ['ReferenceError: DashboardPanel is not defined'];
+      const failures = ComponentErrorAnalyzer.analyzeComponentErrors(errors);
+      expect(failures.length).toBeGreaterThan(0);
+      const panelFailure = failures.find(f => f.componentName === 'DashboardPanel');
+      expect(panelFailure).toBeDefined();
+      expect(panelFailure!.errorType).toBe('not_defined');
+    });
+
+    it('should extract line numbers from errors', () => {
+      const errors = ['ReferenceError: MyComp is not defined at main.js:42:10'];
+      const failures = ComponentErrorAnalyzer.analyzeComponentErrors(errors);
+      const compFailure = failures.find(f => f.componentName === 'MyComp');
+      expect(compFailure).toBeDefined();
+      expect(compFailure!.lineNumber).toBe(42);
+    });
+
+    it('should deduplicate failures by component name and error type', () => {
+      const errors = [
+        'ReferenceError: Widget is not defined',
+        'ReferenceError: Widget is not defined at line 42',
+      ];
+      const failures = ComponentErrorAnalyzer.analyzeComponentErrors(errors);
+      const widgetFailures = failures.filter(f => f.componentName === 'Widget' && f.errorType === 'not_defined');
+      expect(widgetFailures.length).toBe(1);
+    });
+  });
+
+  describe('formatAnalysisResults', () => {
+    it('should format empty results message', () => {
+      const result = ComponentErrorAnalyzer.formatAnalysisResults([]);
+      expect(result).toBe('No component failures detected');
+    });
+
+    it('should format failure details', () => {
+      const failures = [{
+        componentName: 'TestComponent',
+        errorType: 'not_defined',
+        errorMessage: 'ReferenceError: TestComponent is not defined',
+        lineNumber: 10,
+      }];
+      const result = ComponentErrorAnalyzer.formatAnalysisResults(failures);
+      expect(result).toContain('1 component failure(s)');
+      expect(result).toContain('TestComponent');
+      expect(result).toContain('not_defined');
+      expect(result).toContain('Line: 10');
+    });
+
+    it('should truncate long error messages', () => {
+      const longMessage = 'A'.repeat(300);
+      const failures = [{
+        componentName: 'BigError',
+        errorType: 'unknown',
+        errorMessage: longMessage,
+      }];
+      const result = ComponentErrorAnalyzer.formatAnalysisResults(failures);
+      expect(result).toContain('...');
+    });
+  });
+});

package/tsconfig.json

@@ -20,5 +20,5 @@
     "types": ["node"]
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "src/__tests__/**", "src/**/*.test.ts", "src/**/*.spec.ts"]
 }

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineProject, mergeConfig } from 'vitest/config';
+import sharedConfig from '../../../vitest.shared';
+
+export default mergeConfig(sharedConfig, defineProject({
+  test: {
+    environment: 'node',
+  },
+}));

package/{webpack.umd.config.js → webpack.umd.config.cjs}

@@ -40,6 +40,10 @@ module.exports = {
               }]
             ]
           }
+        },
+        // Disable ESM's strict extension requirement for local imports
+        resolve: {
+          fullySpecified: false
         }
       }
     ]