zeropoint-node 1.0.0 → 1.0.1

package/dist/__tests__/stimulus/Application.test.js

@@ -0,0 +1,272 @@
+"use strict";
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stimulus_1 = require("stimulus");
+const ZeroPointController_1 = __importDefault(require("../../stimulus/controllers/ZeroPointController"));
+const MetaphysicalController_1 = __importDefault(require("../../stimulus/controllers/MetaphysicalController"));
+const ControllerTypes_1 = require("../../stimulus/types/ControllerTypes");
+// Mock the window object for testing
+const mockWindow = {
+    ZeroPointApp: null
+};
+Object.defineProperty(global, 'window', {
+    value: mockWindow,
+    writable: true
+});
+// Mock console.log to capture log messages
+const mockConsoleLog = jest.fn();
+Object.defineProperty(console, 'log', {
+    value: mockConsoleLog,
+    writable: true
+});
+describe('ZeroPoint Stimulus Application', () => {
+    let application;
+    beforeEach(() => {
+        // Reset mocks
+        jest.clearAllMocks();
+        mockWindow.ZeroPointApp = null;
+    });
+    describe('Application Initialization', () => {
+        it('should create application with default configuration', () => {
+            // Import the application (this will trigger initialization)
+            const app = require('../../stimulus/application').default;
+            expect(app).toBeDefined();
+            expect(app).toBeInstanceOf(stimulus_1.Application);
+        });
+        it('should register core controllers', () => {
+            const app = require('../../stimulus/application').default;
+            // Check that controllers are registered
+            expect(app.controllers).toBeDefined();
+            expect(Object.keys(app.controllers)).toContain('zeropoint');
+            expect(Object.keys(app.controllers)).toContain('metaphysical');
+        });
+        it('should set up global access in development mode', () => {
+            // Mock NODE_ENV to development
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'development';
+            // Re-import to trigger initialization with development config
+            jest.resetModules();
+            require('../../stimulus/application');
+            expect(mockWindow.ZeroPointApp).toBeDefined();
+            expect(mockWindow.ZeroPointApp).toHaveProperty('application');
+            expect(mockWindow.ZeroPointApp).toHaveProperty('config');
+            expect(mockWindow.ZeroPointApp).toHaveProperty('logs');
+            expect(mockWindow.ZeroPointApp).toHaveProperty('getLogs');
+            expect(mockWindow.ZeroPointApp).toHaveProperty('clearLogs');
+            // Restore original environment
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should set up minimal global access in production mode', () => {
+            // Mock NODE_ENV to production
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+            // Re-import to trigger initialization with production config
+            jest.resetModules();
+            const app = require('../../stimulus/application').default;
+            expect(mockWindow.ZeroPointApp).toBe(app);
+            // Restore original environment
+            process.env.NODE_ENV = originalEnv;
+        });
+    });
+    describe('Logging System', () => {
+        it('should log application startup messages', () => {
+            // Re-import to trigger logging
+            jest.resetModules();
+            require('../../stimulus/application');
+            expect(mockConsoleLog).toHaveBeenCalledWith('ℹ️ [INFO] 🌌 ZeroPoint Stimulus Application Started');
+            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('ℹ️ [INFO] Registered Controllers:'));
+        });
+        it('should log controller registration', () => {
+            // Re-import to trigger logging
+            jest.resetModules();
+            require('../../stimulus/application');
+            expect(mockConsoleLog).toHaveBeenCalledWith('🔍 [DEBUG] Controller \'zeropoint\' registered');
+            expect(mockConsoleLog).toHaveBeenCalledWith('🔍 [DEBUG] Controller \'metaphysical\' registered');
+        });
+        it('should handle controller registration errors', () => {
+            // Mock Application.start to throw an error
+            const originalStart = stimulus_1.Application.start;
+            stimulus_1.Application.start = jest.fn().mockImplementation(() => {
+                throw new Error('Application start failed');
+            });
+            expect(() => {
+                jest.resetModules();
+                require('../../stimulus/application');
+            }).toThrow('Application start failed');
+            // Restore original method
+            stimulus_1.Application.start = originalStart;
+        });
+    });
+    describe('Configuration', () => {
+        it('should use development configuration in development mode', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'development';
+            jest.resetModules();
+            const app = require('../../stimulus/application').default;
+            expect(mockWindow.ZeroPointApp.config.debug).toBe(true);
+            expect(mockWindow.ZeroPointApp.config.logLevel).toBe(ControllerTypes_1.LogLevel.DEBUG);
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should use production configuration in production mode', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+            jest.resetModules();
+            require('../../stimulus/application');
+            expect(mockWindow.ZeroPointApp.config.debug).toBe(false);
+            expect(mockWindow.ZeroPointApp.config.logLevel).toBe(ControllerTypes_1.LogLevel.INFO);
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should use default configuration when NODE_ENV is not set', () => {
+            const originalEnv = process.env.NODE_ENV;
+            delete process.env.NODE_ENV;
+            jest.resetModules();
+            require('../../stimulus/application');
+            expect(mockWindow.ZeroPointApp.config.debug).toBe(false);
+            expect(mockWindow.ZeroPointApp.config.logLevel).toBe(ControllerTypes_1.LogLevel.INFO);
+            process.env.NODE_ENV = originalEnv;
+        });
+    });
+    describe('Log Level Filtering', () => {
+        it('should filter logs based on configured level', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production'; // INFO level
+            jest.resetModules();
+            require('../../stimulus/application');
+            // Should log INFO and ERROR messages, but not DEBUG
+            const logCalls = mockConsoleLog.mock.calls.map(call => call[0]);
+            expect(logCalls.some(call => call.includes('[INFO]'))).toBe(true);
+            expect(logCalls.some(call => call.includes('[ERROR]'))).toBe(false); // No errors in normal startup
+            expect(logCalls.some(call => call.includes('[DEBUG]'))).toBe(false); // DEBUG filtered out in production
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should show DEBUG messages in development mode', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'development'; // DEBUG level
+            jest.resetModules();
+            require('../../stimulus/application');
+            const logCalls = mockConsoleLog.mock.calls.map(call => call[0]);
+            expect(logCalls.some(call => call.includes('[DEBUG]'))).toBe(true);
+            process.env.NODE_ENV = originalEnv;
+        });
+    });
+    describe('Global Access Methods', () => {
+        beforeEach(() => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'development';
+            jest.resetModules();
+            require('../../stimulus/application');
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should provide getLogs method', () => {
+            const logs = mockWindow.ZeroPointApp.getLogs();
+            expect(Array.isArray(logs)).toBe(true);
+            expect(logs.length).toBeGreaterThan(0);
+            // Check log structure
+            const firstLog = logs[0];
+            expect(firstLog).toHaveProperty('level');
+            expect(firstLog).toHaveProperty('message');
+            expect(firstLog).toHaveProperty('timestamp');
+            expect(typeof firstLog.level).toBe('string');
+            expect(typeof firstLog.message).toBe('string');
+            expect(typeof firstLog.timestamp).toBe('number');
+        });
+        it('should provide clearLogs method', () => {
+            const initialLogs = mockWindow.ZeroPointApp.getLogs();
+            expect(initialLogs.length).toBeGreaterThan(0);
+            mockWindow.ZeroPointApp.clearLogs();
+            const clearedLogs = mockWindow.ZeroPointApp.getLogs();
+            expect(clearedLogs.length).toBe(0);
+        });
+        it('should provide application instance', () => {
+            expect(mockWindow.ZeroPointApp.application).toBeDefined();
+            expect(mockWindow.ZeroPointApp.application).toBeInstanceOf(stimulus_1.Application);
+        });
+        it('should provide configuration', () => {
+            expect(mockWindow.ZeroPointApp.config).toBeDefined();
+            expect(mockWindow.ZeroPointApp.config).toHaveProperty('debug');
+            expect(mockWindow.ZeroPointApp.config).toHaveProperty('logLevel');
+            expect(mockWindow.ZeroPointApp.config).toHaveProperty('controllers');
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle controller registration errors gracefully', () => {
+            var _a;
+            // Mock a controller that throws an error
+            const MockController = (_a = class {
+                },
+                __setFunctionName(_a, "MockController"),
+                _a.targets = [],
+                _a);
+            // This would normally be handled by the application class
+            // We're testing the error handling pattern
+            expect(() => {
+                const app = stimulus_1.Application.start();
+                app.register('test', MockController);
+            }).not.toThrow();
+        });
+        it('should log errors with appropriate level', () => {
+            // Mock console.error to capture error logs
+            const mockConsoleError = jest.fn();
+            const originalError = console.error;
+            console.error = mockConsoleError;
+            try {
+                // Trigger an error by trying to register an invalid controller
+                const app = stimulus_1.Application.start();
+                app.register('invalid', null);
+            }
+            catch (error) {
+                // Error should be caught and logged
+            }
+            expect(mockConsoleError).toHaveBeenCalled();
+            console.error = originalError;
+        });
+    });
+    describe('Controller Integration', () => {
+        it('should properly register ZeroPointController', () => {
+            const app = require('../../stimulus/application').default;
+            expect(app.controllers.zeropoint).toBe(ZeroPointController_1.default);
+        });
+        it('should properly register MetaphysicalController', () => {
+            const app = require('../../stimulus/application').default;
+            expect(app.controllers.metaphysical).toBe(MetaphysicalController_1.default);
+        });
+        it('should have correct controller names', () => {
+            const app = require('../../stimulus/application').default;
+            const controllerNames = Object.keys(app.controllers);
+            expect(controllerNames).toContain('zeropoint');
+            expect(controllerNames).toContain('metaphysical');
+            expect(controllerNames.length).toBe(2);
+        });
+    });
+    describe('Type Safety', () => {
+        it('should have correct LogLevel enum values', () => {
+            expect(ControllerTypes_1.LogLevel.DEBUG).toBe('debug');
+            expect(ControllerTypes_1.LogLevel.INFO).toBe('info');
+            expect(ControllerTypes_1.LogLevel.WARN).toBe('warn');
+            expect(ControllerTypes_1.LogLevel.ERROR).toBe('error');
+        });
+        it('should have correct log entry structure', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'development';
+            jest.resetModules();
+            require('../../stimulus/application');
+            const logs = mockWindow.ZeroPointApp.getLogs();
+            const logEntry = logs[0];
+            expect(logEntry).toHaveProperty('level');
+            expect(logEntry).toHaveProperty('message');
+            expect(logEntry).toHaveProperty('timestamp');
+            expect(logEntry).toHaveProperty('operation');
+            expect(logEntry).toHaveProperty('data');
+            expect(Object.values(ControllerTypes_1.LogLevel)).toContain(logEntry.level);
+            expect(typeof logEntry.message).toBe('string');
+            expect(typeof logEntry.timestamp).toBe('number');
+            process.env.NODE_ENV = originalEnv;
+        });
+    });
+});

package/dist/__tests__/stimulus/BaseController.test.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseController_1 = __importDefault(require("../../stimulus/base/BaseController"));
+const ConsciousnessField_1 = require("../../consciousness/ConsciousnessField");
+const VortexMath_1 = require("../../math/VortexMath");
+const ToroidalGeometry_1 = require("../../math/ToroidalGeometry");
+const AdvancedVBM_1 = require("../../math/AdvancedVBM");
+const RodinCoil_1 = require("../../math/RodinCoil");
+/**
+ * Test BaseController
+ *
+ * Tests the shared functionality provided by BaseController
+ */
+class TestController extends BaseController_1.default {
+    // Expose protected methods for testing
+    testInitializeComponents() {
+        this.initializeComponents();
+    }
+    testExecuteSafely(operation, errorMessage) {
+        return this.executeSafely(operation, errorMessage);
+    }
+    testUpdateTargetSafely(target, content, className) {
+        this.updateTargetSafely(target, content, className);
+    }
+    testGenerateInsights() {
+        return this.generateInsights();
+    }
+    testFormatInsightsHTML(insights) {
+        return this.formatInsightsHTML(insights);
+    }
+    testUpdateStatus(target, message, className) {
+        this.updateStatus(target, message, className);
+    }
+    testLogOperation(operation, success = true) {
+        this.logOperation(operation, success);
+    }
+}
+TestController.targets = ["test"];
+describe('BaseController', () => {
+    let controller;
+    let mockElement;
+    beforeEach(() => {
+        controller = new TestController();
+        mockElement = document.createElement('div');
+    });
+    describe('Component Initialization', () => {
+        it('should initialize all components correctly', () => {
+            controller.testInitializeComponents();
+            expect(controller.consciousnessField).toBeInstanceOf(ConsciousnessField_1.ConsciousnessField);
+            expect(controller.vortexMath).toBeInstanceOf(VortexMath_1.VortexMath);
+            expect(controller.toroidalGeometry).toBeInstanceOf(ToroidalGeometry_1.ToroidalGeometry);
+            expect(controller.advancedVBM).toBeInstanceOf(AdvancedVBM_1.AdvancedVBM);
+            expect(controller.rodinCoil).toBeInstanceOf(RodinCoil_1.RodinCoil);
+        });
+        it('should initialize components safely with success', async () => {
+            const result = await controller.initializeComponentsSafely();
+            expect(result).toBe(true);
+        });
+        it('should handle initialization errors gracefully', async () => {
+            // Mock a component that throws an error
+            jest.spyOn(controller, 'initializeComponents').mockImplementation(() => {
+                throw new Error('Initialization failed');
+            });
+            const result = await controller.initializeComponentsSafely();
+            expect(result).toBe(false);
+        });
+    });
+    describe('Display Updates', () => {
+        beforeEach(() => {
+            controller.testInitializeComponents();
+        });
+        it('should update consciousness display correctly', () => {
+            controller.updateConsciousnessDisplay(mockElement);
+            expect(mockElement.textContent).toMatch(/Consciousness: \d+\.\d{3}/);
+        });
+        it('should update consciousness display with custom level', () => {
+            controller.updateConsciousnessDisplay(mockElement, 0.75);
+            expect(mockElement.textContent).toBe('Consciousness: 0.750');
+        });
+        it('should update vortex math display correctly', () => {
+            controller.updateVortexMathDisplay(mockElement);
+            expect(mockElement.textContent).toMatch(/Vortex Result: \d+\.\d{3}/);
+        });
+        it('should update vortex math display with custom input', () => {
+            controller.updateVortexMathDisplay(mockElement, 42);
+            expect(mockElement.textContent).toMatch(/Vortex Result: \d+\.\d{3}/);
+        });
+        it('should update toroidal geometry display correctly', () => {
+            controller.updateToroidalGeometryDisplay(mockElement);
+            expect(mockElement.textContent).toMatch(/Toroidal Volume: \d+\.\d{3}/);
+        });
+    });
+    describe('Safe Operations', () => {
+        it('should execute operations safely with success', async () => {
+            const operation = () => 42;
+            const result = await controller.testExecuteSafely(operation, 'Test operation');
+            expect(result).toBe(42);
+        });
+        it('should handle operation errors gracefully', async () => {
+            const operation = () => {
+                throw new Error('Operation failed');
+            };
+            const result = await controller.testExecuteSafely(operation, 'Test operation');
+            expect(result).toBeNull();
+        });
+        it('should use default error message when none provided', async () => {
+            const operation = () => {
+                throw new Error('Operation failed');
+            };
+            const result = await controller.testExecuteSafely(operation);
+            expect(result).toBeNull();
+        });
+    });
+    describe('Target Updates', () => {
+        it('should update target safely with content', () => {
+            controller.testUpdateTargetSafely(mockElement, '<p>Test content</p>');
+            expect(mockElement.innerHTML).toBe('<p>Test content</p>');
+        });
+        it('should update target safely with content and className', () => {
+            controller.testUpdateTargetSafely(mockElement, '<p>Test content</p>', 'test-class');
+            expect(mockElement.innerHTML).toBe('<p>Test content</p>');
+            expect(mockElement.className).toBe('test-class');
+        });
+        it('should handle target update errors gracefully', () => {
+            // Mock innerHTML to throw an error
+            Object.defineProperty(mockElement, 'innerHTML', {
+                set: () => { throw new Error('Update failed'); }
+            });
+            controller.testUpdateTargetSafely(mockElement, '<p>Test content</p>');
+            expect(mockElement.innerHTML).toContain('❌ Update failed');
+        });
+    });
+    describe('Insights Generation', () => {
+        beforeEach(() => {
+            controller.testInitializeComponents();
+        });
+        it('should generate insights with correct structure', () => {
+            const insights = controller.testGenerateInsights();
+            expect(insights).toHaveProperty('version');
+            expect(insights).toHaveProperty('environment');
+            expect(insights).toHaveProperty('features');
+            expect(insights).toHaveProperty('browser');
+            expect(insights).toHaveProperty('consciousness');
+            expect(insights.version).toBe('1.0.0');
+            expect(insights.environment).toBe('browser');
+            expect(Array.isArray(insights.features)).toBe(true);
+            expect(typeof insights.browser.userAgent).toBe('string');
+            expect(typeof insights.consciousness.level).toBe('number');
+            expect(typeof insights.consciousness.field).toBe('number');
+        });
+        it('should format insights as HTML correctly', () => {
+            const insights = controller.testGenerateInsights();
+            const html = controller.testFormatInsightsHTML(insights);
+            expect(html).toContain('<h3>ZeroPoint Insights</h3>');
+            expect(html).toContain(`<strong>Version:</strong> ${insights.version}`);
+            expect(html).toContain(`<strong>Environment:</strong> ${insights.environment}`);
+            expect(html).toContain(`<strong>Features:</strong> ${insights.features.join(", ")}`);
+            expect(html).toContain(`<strong>Browser:</strong> ${insights.browser.userAgent}`);
+            expect(html).toContain(`<strong>Consciousness Level:</strong> ${insights.consciousness.level.toFixed(3)}`);
+            expect(html).toContain(`<strong>Field Strength:</strong> ${insights.consciousness.field.toFixed(3)}`);
+        });
+    });
+    describe('Status Updates', () => {
+        it('should update status correctly', () => {
+            controller.testUpdateStatus(mockElement, '✅ Ready', 'status ready');
+            expect(mockElement.innerHTML).toBe('✅ Ready');
+            expect(mockElement.className).toBe('status ready');
+        });
+        it('should handle status update errors gracefully', () => {
+            // Mock innerHTML to throw an error
+            Object.defineProperty(mockElement, 'innerHTML', {
+                set: () => { throw new Error('Status update failed'); }
+            });
+            controller.testUpdateStatus(mockElement, '✅ Ready', 'status ready');
+            expect(mockElement.innerHTML).toContain('❌ Update failed');
+        });
+    });
+    describe('Logging', () => {
+        let consoleSpy;
+        beforeEach(() => {
+            consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        });
+        afterEach(() => {
+            consoleSpy.mockRestore();
+        });
+        it('should log successful operations', () => {
+            controller.testLogOperation('Test operation', true);
+            expect(consoleSpy).toHaveBeenCalledWith('✅ Test operation completed');
+        });
+        it('should log failed operations', () => {
+            controller.testLogOperation('Test operation', false);
+            expect(consoleSpy).toHaveBeenCalledWith('❌ Test operation failed');
+        });
+    });
+});