zeropoint-node 1.0.1 → 1.0.3

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

@@ -1,272 +0,0 @@
-"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

@@ -1,198 +0,0 @@
-"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');
-        });
-    });
-});