@bookklik/senangstart-css 0.2.10 → 0.2.12

package/src/utils/node-io.js

@@ -0,0 +1,82 @@
+/**
+ * SenangStart CSS - Node.js I/O Utilities
+ * Node-specific helper functions (not for browser use)
+ */
+
+/**
+ * Read file with timeout protection
+ * @param {string} filePath - Path to file
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @returns {Promise<string>} - File contents
+ * @throws {Error} - On timeout or read failure
+ */
+export async function readFileWithTimeout(filePath, timeoutMs = 5000) {
+  const { promises: fsPromises, statSync } = await import('fs');
+
+  // Check file size first
+  let fileSize;
+  try {
+    const stats = statSync(filePath);
+    fileSize = stats.size;
+
+    // Reject files larger than 10MB
+    const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+    if (fileSize > MAX_FILE_SIZE) {
+      throw new Error(`File too large: ${filePath} (${Math.round(fileSize / 1024)}KB)`);
+    }
+  } catch (error) {
+    throw new Error(`Cannot stat file: ${filePath} - ${error.message}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Read timeout for ${filePath} (exceeded ${timeoutMs}ms)`));
+    }, timeoutMs);
+
+    fsPromises.readFile(filePath, 'utf-8')
+      .then((content) => {
+        clearTimeout(timeout);
+        resolve(content);
+      })
+      .catch((error) => {
+        clearTimeout(timeout);
+        reject(new Error(`Cannot read file: ${filePath} - ${error.message}`));
+      });
+  });
+}
+
+/**
+ * Batch read multiple files with timeout protection
+ * @param {Array<string>} filePaths - Paths to files
+ * @param {number} timeoutMs - Timeout per file
+ * @returns {Promise<Array<{path: string, content: string, error: Error|null}>>} - File contents
+ */
+export async function readMultipleFilesWithTimeout(filePaths, timeoutMs = 5000) {
+  const results = [];
+
+  // Read files in batches to avoid overwhelming the system
+  const BATCH_SIZE = 10;
+
+  for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
+    const batch = filePaths.slice(i, i + BATCH_SIZE);
+
+    const batchPromises = batch.map(async (filePath) => {
+      try {
+        const content = await readFileWithTimeout(filePath, timeoutMs);
+        return { path: filePath, content, error: null };
+      } catch (error) {
+        return { path: filePath, content: null, error };
+      }
+    });
+
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
+  }
+
+  return results;
+}
+
+export default {
+  readFileWithTimeout,
+  readMultipleFilesWithTimeout
+};

package/tests/integration/dev-recovery.test.js

@@ -0,0 +1,231 @@
+/**
+ * Dev Mode Error Recovery Tests
+ * Tests for error recovery mechanisms in development mode
+ */
+
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert';
+
+describe('Dev Mode Error Recovery', () => {
+  describe('Consecutive Error Tracking', () => {
+    it('tracks consecutive build failures', async () => {
+      let errorCount = 0;
+      const MAX_ERRORS = 5;
+
+      const mockBuild = async () => {
+        errorCount++;
+        if (errorCount < MAX_ERRORS) {
+          throw new Error('Simulated build error');
+        }
+        return { css: '', tokens: [] };
+      };
+
+      // Simulate consecutive errors
+      for (let i = 0; i < MAX_ERRORS; i++) {
+        try {
+          await mockBuild();
+        } catch (e) {
+          // Expected error
+        }
+      }
+
+      assert.strictEqual(errorCount, MAX_ERRORS);
+    });
+
+    it('resets error count on successful build', async () => {
+      let errorCount = 0;
+      const MAX_ERRORS = 3;
+
+      const mockBuild = async (forceError = false) => {
+        if (forceError) {
+          errorCount++;
+          throw new Error('Simulated build error');
+        }
+
+        // Successful build resets count
+        errorCount = 0;
+        return { css: '', tokens: [] };
+      };
+
+      // Accumulate errors
+      for (let i = 0; i < MAX_ERRORS; i++) {
+        try {
+          await mockBuild(true);
+        } catch (e) {
+          // Expected error
+        }
+      }
+
+      // Error count should be MAX_ERRORS after failures
+      assert.strictEqual(errorCount, MAX_ERRORS);
+
+      // Successful build should reset count
+      await mockBuild(false);
+      assert.strictEqual(errorCount, 0);
+    });
+
+    it('prevents builds during cooldown period', async () => {
+      let errorCount = 0;
+      let cooldownActive = false;
+      const MAX_ERRORS = 5;
+
+      const mockBuild = async () => {
+        if (cooldownActive) {
+          throw new Error('Cooldown active');
+        }
+
+        errorCount++;
+        if (errorCount >= MAX_ERRORS) {
+          cooldownActive = true;
+        }
+        throw new Error('Simulated build error');
+      };
+
+      // Trigger cooldown
+      for (let i = 0; i < MAX_ERRORS; i++) {
+        try {
+          await mockBuild();
+        } catch (e) {
+          // Expected error
+        }
+      }
+
+      assert.strictEqual(cooldownActive, true);
+
+      // Try to build during cooldown
+      let cooldownError = null;
+      try {
+        await mockBuild();
+      } catch (e) {
+        cooldownError = e.message;
+      }
+
+      assert.strictEqual(cooldownError, 'Cooldown active');
+    });
+  });
+
+  describe('Error Messages', () => {
+    it('logs error count when builds fail', async () => {
+      const errorLog = [];
+      let errorCount = 0;
+
+      const mockLogger = {
+        error: (msg) => errorLog.push(msg),
+        warn: (msg) => errorLog.push(msg),
+        info: (msg) => errorLog.push(msg)
+      };
+
+      const mockBuild = async () => {
+        errorCount++;
+        mockLogger.error(`Build failed (${errorCount}/5): Test error`);
+        throw new Error('Test error');
+      };
+
+      for (let i = 0; i < 3; i++) {
+        try {
+          await mockBuild();
+        } catch (e) {
+          // Expected error
+        }
+      }
+
+      assert.ok(errorLog.some(msg => msg.includes('Build failed (1/5)')));
+      assert.ok(errorLog.some(msg => msg.includes('Build failed (2/5)')));
+      assert.ok(errorLog.some(msg => msg.includes('Build failed (3/5)')));
+    });
+
+    it('logs cooldown activation message', async () => {
+      const errorLog = [];
+      const COOLDOWN_DURATION = 30000;
+
+      const mockLogger = {
+        error: (msg) => errorLog.push(msg),
+        warn: (msg) => errorLog.push(msg)
+      };
+
+      const mockBuild = async () => {
+        mockLogger.warn(`Maximum consecutive errors (5) reached.`);
+        mockLogger.warn(`Entering ${COOLDOWN_DURATION / 1000}s cooldown to prevent resource exhaustion.`);
+        throw new Error('Max errors reached');
+      };
+
+      try {
+        await mockBuild();
+      } catch (e) {
+        // Expected error
+      }
+
+      assert.ok(errorLog.some(msg => msg.includes('Maximum consecutive errors')));
+      assert.ok(errorLog.some(msg => msg.includes('cooldown')));
+    });
+  });
+
+  describe('Build Lock Mechanism', () => {
+    it('prevents overlapping builds', async () => {
+      let buildInProgress = false;
+      let pendingBuild = false;
+      let buildCount = 0;
+
+      const mockBuild = async () => {
+        if (buildInProgress) {
+          pendingBuild = true;
+          return;
+        }
+
+        buildInProgress = true;
+        buildCount++;
+        await new Promise(resolve => setTimeout(resolve, 100));
+        buildInProgress = false;
+
+        if (pendingBuild) {
+          pendingBuild = false;
+          await mockBuild();
+        }
+      };
+
+      // Trigger multiple builds in parallel
+      await Promise.all([
+        mockBuild(),
+        mockBuild(),
+        mockBuild()
+      ]);
+
+      // Should execute at least 2 builds (one initial, one from pending)
+      assert.ok(buildCount >= 2);
+    });
+
+    it('processes pending builds after current build completes', async () => {
+      let buildInProgress = false;
+      let pendingBuild = false;
+      let buildCount = 0;
+
+      const mockBuild = async () => {
+        if (buildInProgress) {
+          pendingBuild = true;
+          return;
+        }
+
+        buildInProgress = true;
+        buildCount++;
+        await new Promise(resolve => setTimeout(resolve, 50));
+        buildInProgress = false;
+
+        if (pendingBuild) {
+          pendingBuild = false;
+          await mockBuild();
+        }
+      };
+
+      // Trigger build
+      mockBuild();
+
+      // Immediately trigger another build while first is in progress
+      setTimeout(() => mockBuild(), 10);
+
+      // Wait for all builds to complete
+      await new Promise(resolve => setTimeout(resolve, 200));
+
+      assert.strictEqual(buildCount, 2);
+    });
+  });
+});

package/tests/unit/cli/memory-limits.test.js

@@ -0,0 +1,169 @@
+/**
+ * Memory Usage Limits Tests
+ * Tests for memory protection and batch processing
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { getMemoryUsage, isMemorySafe, batchProcessWithMemoryLimit, batchProcessTokens } from '../../../src/utils/common.js';
+
+describe('Memory Usage Limits', () => {
+  describe('getMemoryUsage', () => {
+    it('returns a number', () => {
+      const memory = getMemoryUsage();
+      assert.ok(typeof memory === 'number');
+    });
+
+    it('returns positive value', () => {
+      const memory = getMemoryUsage();
+      assert.ok(memory >= 0);
+    });
+
+    it('returns value in reasonable range', () => {
+      const memory = getMemoryUsage();
+      // Should be between 0 and a few GB in typical usage
+      assert.ok(memory < 10000); // Less than 10GB
+    });
+  });
+
+  describe('isMemorySafe', () => {
+    it('returns true for normal memory usage', () => {
+      const safe = isMemorySafe(500);
+      assert.strictEqual(typeof safe, 'boolean');
+    });
+
+    it('uses default limit of 500MB', () => {
+      const safe = isMemorySafe();
+      assert.strictEqual(typeof safe, 'boolean');
+    });
+
+    it('respects custom memory limit', () => {
+      const safe = isMemorySafe(1000);
+      assert.strictEqual(typeof safe, 'boolean');
+    });
+
+    it('returns false when memory exceeds limit', () => {
+      // Use a very low limit to ensure current usage exceeds it
+      const safe = isMemorySafe(1);
+      assert.strictEqual(safe, false);
+    });
+  });
+
+  describe('batchProcessWithMemoryLimit', () => {
+    it('processes all items in array', async () => {
+      const items = [1, 2, 3, 4, 5];
+      const processor = (item) => item * 2;
+
+      const results = await batchProcessWithMemoryLimit(items, processor, 10, 500);
+      assert.deepStrictEqual(results, [2, 4, 6, 8, 10]);
+    });
+
+    it('processes items in batches', async () => {
+      const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+      const processor = (item) => item * 2;
+
+      const results = await batchProcessWithMemoryLimit(items, processor, 3, 500);
+      assert.deepStrictEqual(results, [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
+    });
+
+    it('handles empty array', async () => {
+      const results = await batchProcessWithMemoryLimit([], (item) => item, 10, 500);
+      assert.deepStrictEqual(results, []);
+    });
+
+    it('handles large arrays without crashing', async () => {
+      const items = Array(100).fill(0).map((_, i) => i);
+      const processor = (item) => item * 2;
+
+      const results = await batchProcessWithMemoryLimit(items, processor, 20, 500);
+      assert.strictEqual(results.length, 100);
+      assert.strictEqual(results[0], 0);
+      assert.strictEqual(results[99], 198);
+    });
+
+    it('preserves item order', async () => {
+      const items = [5, 2, 8, 1, 9];
+      const processor = (item) => item;
+
+      const results = await batchProcessWithMemoryLimit(items, processor, 2, 500);
+      assert.deepStrictEqual(results, [5, 2, 8, 1, 9]);
+    });
+  });
+
+  describe('batchProcessTokens', () => {
+    it('processes token objects', async () => {
+      const tokens = [
+        { raw: 'flex', attrType: 'layout' },
+        { raw: 'center', attrType: 'layout' },
+        { raw: 'p:medium', attrType: 'space' }
+      ];
+
+      const processor = (token) => ({ ...token, processed: true });
+
+      const results = await batchProcessTokens(tokens, processor, 2);
+      assert.strictEqual(results.length, 3);
+      assert.ok(results.every(r => r.processed === true));
+    });
+
+    it('handles large token arrays', async () => {
+      const tokens = Array(1000).fill(null).map((_, i) => ({
+        raw: `test${i}`,
+        attrType: 'layout'
+      }));
+
+      const processor = (token) => ({ ...token, index: tokens.indexOf(token) });
+
+      const results = await batchProcessTokens(tokens, processor, 100);
+      assert.strictEqual(results.length, 1000);
+    });
+
+    it('preserves token data', async () => {
+      const tokens = [
+        { raw: 'flex', attrType: 'layout', property: 'flex' },
+        { raw: 'grid', attrType: 'layout', property: 'grid' }
+      ];
+
+      const processor = (token) => token;
+
+      const results = await batchProcessTokens(tokens, processor, 1);
+      assert.deepStrictEqual(results, tokens);
+    });
+  });
+
+  describe('Memory Error Handling', () => {
+    it('processes items without memory errors under normal conditions', async () => {
+      // This test verifies the memory limit handling works under normal conditions
+      // Actual memory limit errors are difficult to test in unit test environment
+
+      const items = [1, 2, 3];
+      const processor = (item) => item;
+
+      const results = await batchProcessWithMemoryLimit(items, processor, 1, 500);
+      assert.strictEqual(results.length, 3);
+      assert.deepStrictEqual(results, [1, 2, 3]);
+    });
+  });
+
+  describe('Batch Size Configuration', () => {
+    it('respects custom batch size', async () => {
+      const items = [1, 2, 3, 4, 5];
+      const batchesProcessed = [];
+
+      const processor = (item) => {
+        batchesProcessed.push(item);
+        return item * 2;
+      };
+
+      await batchProcessWithMemoryLimit(items, processor, 2, 500);
+      assert.strictEqual(batchesProcessed.length, 5);
+    });
+
+    it('uses default batch size of 1000', async () => {
+      const items = Array(500).fill(0).map((_, i) => i);
+      const processor = (item) => item * 2;
+
+      const results = await batchProcessTokens(items, processor);
+      assert.strictEqual(results.length, 500);
+    });
+  });
+});

package/tests/unit/compiler/css-generation-error-handling.test.js

@@ -0,0 +1,204 @@
+/**
+ * CSS Generator Error Handling Tests
+ * Tests for error boundaries and graceful degradation
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { generateRule, generateCSS } from '../../../src/compiler/generators/css.js';
+import { defaultConfig } from '../../../src/config/defaults.js';
+
+describe('CSS Generator Error Handling', () => {
+  describe('generateRule', () => {
+    it('handles null token gracefully', () => {
+      const result = generateRule(null, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles undefined token gracefully', () => {
+      const result = generateRule(undefined, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles token with missing attrType', () => {
+      const token = {
+        raw: 'flex',
+        property: 'flex',
+        value: 'flex'
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles token with missing raw value', () => {
+      const token = {
+        attrType: 'layout',
+        property: 'flex',
+        value: 'flex'
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles token with invalid attrType', () => {
+      const token = {
+        raw: 'flex',
+        attrType: 'invalid',
+        property: 'flex',
+        value: 'flex'
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles malformed layout rule without crashing', () => {
+      const token = {
+        raw: 'test',
+        attrType: 'layout',
+        property: null,
+        value: null
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles malformed space rule without crashing', () => {
+      const token = {
+        raw: 'test',
+        attrType: 'space',
+        property: null,
+        value: null
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles malformed visual rule without crashing', () => {
+      const token = {
+        raw: 'test',
+        attrType: 'visual',
+        property: null,
+        value: null
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+  });
+
+  describe('generateCSS', () => {
+    it('handles null tokens array', () => {
+      const result = generateCSS(null, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles undefined tokens array', () => {
+      const result = generateCSS(undefined, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles empty tokens array', () => {
+      const result = generateCSS([], defaultConfig);
+      assert.ok(typeof result === 'string');
+      assert.ok(result.includes(':root'));
+      assert.ok(!result.includes('[layout~="'));
+    });
+
+    it('handles malformed tokens without crashing', () => {
+      const malformedTokens = [
+        null,
+        undefined,
+        { raw: 'test' },
+        { attrType: 'layout' },
+        { raw: 'test', attrType: 'invalid' }
+      ];
+      const result = generateCSS(malformedTokens, defaultConfig);
+      assert.ok(typeof result === 'string');
+      assert.ok(result.includes(':root'));
+    });
+
+    it('handles valid tokens mixed with malformed ones', () => {
+      const mixedTokens = [
+        { raw: 'flex', attrType: 'layout', property: 'flex', value: 'flex' },
+        null,
+        { raw: 'center', attrType: 'layout', property: 'items', value: 'center' },
+        undefined,
+        { raw: 'p:medium', attrType: 'space', property: 'p', value: 'medium' }
+      ];
+      const result = generateCSS(mixedTokens, defaultConfig);
+      assert.ok(typeof result === 'string');
+      assert.ok(result.includes('[layout~="flex"]'));
+      assert.ok(result.includes('[layout~="center"]'));
+      assert.ok(result.includes('[space~="p:medium"]'));
+    });
+
+    it('handles null config gracefully', () => {
+      const result = generateCSS([], null);
+      assert.strictEqual(result, '');
+    });
+
+    it('handles invalid config gracefully', () => {
+      const result = generateCSS([], 'invalid');
+      assert.strictEqual(result, '');
+    });
+
+    it('handles config with missing theme', () => {
+      const invalidConfig = { ...defaultConfig, theme: null };
+      const result = generateCSS([], invalidConfig);
+      assert.ok(typeof result === 'string');
+    });
+
+    it('handles tokens with invalid state values', () => {
+      const invalidTokens = [
+        { raw: 'flex:invalid', attrType: 'layout', property: 'flex', value: 'flex', state: 'invalid-state' }
+      ];
+      const result = generateCSS(invalidTokens, defaultConfig);
+      assert.ok(typeof result === 'string');
+    });
+
+    it('handles tokens with invalid breakpoint values', () => {
+      const invalidTokens = [
+        { raw: 'invalid:flex', attrType: 'layout', property: 'flex', value: 'flex', breakpoint: 'invalid-bp' }
+      ];
+      const result = generateCSS(invalidTokens, defaultConfig);
+      assert.ok(typeof result === 'string');
+    });
+  });
+
+  describe('CSS Rule Validation', () => {
+    it('always generates valid declarations with semicolons', () => {
+      const token = {
+        raw: 'flex',
+        attrType: 'layout',
+        property: 'flex',
+        value: 'flex'
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.ok(result.includes('{'));
+      assert.ok(result.includes('}'));
+      assert.ok(result.includes(';'));
+      assert.ok(result.endsWith('}\n'));
+    });
+
+    it('rejects declarations without property', () => {
+      const token = {
+        raw: 'test',
+        attrType: 'layout',
+        property: '',
+        value: 'flex'
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+
+    it('rejects declarations without value', () => {
+      const token = {
+        raw: 'test',
+        attrType: 'layout',
+        property: 'display',
+        value: ''
+      };
+      const result = generateRule(token, defaultConfig);
+      assert.strictEqual(result, '');
+    });
+  });
+});