meno-core 1.0.53 → 1.1.0

package/lib/server/runtime/httpServer.ts

@@ -34,9 +34,7 @@ export interface ServerOptions {
   wsPath?: string;
 }
 
-export async function createRuntimeServer(
-  options: ServerOptions,
-): Promise<RuntimeServer> {
+export async function createRuntimeServer(options: ServerOptions): Promise<RuntimeServer> {
   if (isBun) {
     return createBunServer(options);
   }
@@ -46,7 +44,7 @@ export async function createRuntimeServer(
 // ── Bun implementation ───────────────────────────────────────────────
 
 function createBunServer(options: ServerOptions): RuntimeServer {
-  const { port, hostname, fetch, websocket, wsPath } = options;
+  const { port, hostname, fetch, websocket, wsPath: _wsPath } = options;
 
   const bunConfig: any = {
     port,
@@ -91,7 +89,7 @@ function createBunServer(options: ServerOptions): RuntimeServer {
 
 async function createNodeServer(options: ServerOptions): Promise<RuntimeServer> {
   const { port, hostname, fetch, websocket, wsPath } = options;
-  const http = await import('http');
+  const http = await import('node:http');
 
   const server = http.createServer(async (nodeReq, nodeRes) => {
     try {
@@ -110,7 +108,7 @@ async function createNodeServer(options: ServerOptions): Promise<RuntimeServer>
 
       let body: ReadableStream | null = null;
       if (nodeReq.method !== 'GET' && nodeReq.method !== 'HEAD') {
-        const { Readable } = await import('stream');
+        const { Readable } = await import('node:stream');
         body = Readable.toWeb(nodeReq) as unknown as ReadableStream;
       }
 
@@ -118,7 +116,7 @@ async function createNodeServer(options: ServerOptions): Promise<RuntimeServer>
         method: nodeReq.method || 'GET',
         headers,
         body,
-        // @ts-ignore - duplex is needed for streaming request bodies in Node
+        // @ts-expect-error - duplex is needed for streaming request bodies in Node
         duplex: body ? 'half' : undefined,
       });
 
@@ -171,10 +169,7 @@ async function createNodeServer(options: ServerOptions): Promise<RuntimeServer>
       const wss = new WebSocketServer({ noServer: true });
 
       server.on('upgrade', (request, socket, head) => {
-        const pathname = new URL(
-          request.url || '/',
-          `http://${hostname || 'localhost'}:${port}`,
-        ).pathname;
+        const pathname = new URL(request.url || '/', `http://${hostname || 'localhost'}:${port}`).pathname;
 
         if (pathname === wsPath) {
           wss.handleUpgrade(request, socket, head, (ws) => {
@@ -188,7 +183,8 @@ async function createNodeServer(options: ServerOptions): Promise<RuntimeServer>
       wss.on('connection', (ws) => {
         const client: RuntimeWSClient = {
           send(data) {
-            if (ws.readyState === 1) { // OPEN
+            if (ws.readyState === 1) {
+              // OPEN
               ws.send(data);
             }
           },

package/lib/server/services/ColorService.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { join } from 'path';
-import { mkdirSync, rmSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
 import { setProjectRoot, getProjectRoot } from '../projectContext';
 import { ColorService } from './ColorService';
 import type { ThemeConfig } from '../../shared/types';
@@ -54,7 +54,7 @@ describe('ColorService', () => {
       writeColors(VALID_CONFIG);
       const config = await service.loadThemeConfig();
       expect(config.default).toBe('light');
-      expect(config.themes.light.colors.primary).toBe('#0066ff');
+      expect(config.themes.light!.colors.primary).toBe('#0066ff');
     });
 
     test('returns defaults when file missing', async () => {

package/lib/server/services/ColorService.ts

@@ -9,6 +9,9 @@ import type { ColorVariables, ColorVariableEntry, ThemeConfig, ThemeEntry } from
 import { resolvePaletteColor } from '../../shared/types';
 import { CachedConfigLoader } from './CachedConfigLoader';
 import { writeFile } from '../runtime';
+import { createLogger } from '../../shared/logger';
+
+const log = createLogger('ColorService');
 
 export class ColorService extends CachedConfigLoader<ThemeConfig> {
   /**
@@ -31,7 +34,7 @@ export class ColorService extends CachedConfigLoader<ThemeConfig> {
         }
       }
     } catch (error) {
-      console.warn('Failed to load colors.json:', error);
+      log.warn('Failed to load colors.json:', error);
     }
 
     // Return default theme config if file not found or invalid
@@ -48,44 +51,44 @@ export class ColorService extends CachedConfigLoader<ThemeConfig> {
         dark: {
           label: 'Dark',
           colors: {
-            'primary': '#007acc',
+            primary: '#007acc',
             'primary-light': '#0099ff',
             'primary-dark': '#005a99',
-            'secondary': '#6c757d',
-            'success': '#28a745',
-            'warning': '#ffc107',
-            'danger': '#dc3545',
-            'error': '#d32f2f',
-            'info': '#17a2b8',
-            'light': '#f8f9fa',
-            'dark': '#343a40',
-            'text': '#cccccc',
+            secondary: '#6c757d',
+            success: '#28a745',
+            warning: '#ffc107',
+            danger: '#dc3545',
+            error: '#d32f2f',
+            info: '#17a2b8',
+            light: '#f8f9fa',
+            dark: '#343a40',
+            text: '#cccccc',
             'text-dark': '#1e1e1e',
-            'background': '#1e1e1e',
+            background: '#1e1e1e',
             'background-light': '#252526',
-            'border': '#444444',
+            border: '#444444',
             'border-light': '#d0d0d0',
           },
         },
         light: {
           label: 'Light',
           colors: {
-            'primary': '#0066ff',
+            primary: '#0066ff',
             'primary-light': '#3385ff',
             'primary-dark': '#0052cc',
-            'secondary': '#888888',
-            'success': '#22c55e',
-            'warning': '#f59e0b',
-            'danger': '#ef4444',
-            'error': '#dc2626',
-            'info': '#06b6d4',
-            'light': '#f8f9fa',
-            'dark': '#1f2937',
-            'text': '#1f2937',
+            secondary: '#888888',
+            success: '#22c55e',
+            warning: '#f59e0b',
+            danger: '#ef4444',
+            error: '#dc2626',
+            info: '#06b6d4',
+            light: '#f8f9fa',
+            dark: '#1f2937',
+            text: '#1f2937',
             'text-dark': '#ffffff',
-            'background': '#ffffff',
+            background: '#ffffff',
             'background-light': '#f3f4f6',
-            'border': '#d1d5db',
+            border: '#d1d5db',
             'border-light': '#e5e7eb',
           },
         },
@@ -103,8 +106,8 @@ export class ColorService extends CachedConfigLoader<ThemeConfig> {
         default: {
           label: 'Default',
           colors: {
-            'background': '#1e1e1e',
-            'text': '#cccccc',
+            background: '#1e1e1e',
+            text: '#cccccc',
           },
         },
       },
@@ -131,7 +134,12 @@ export class ColorService extends CachedConfigLoader<ThemeConfig> {
       if (data && typeof data === 'object' && 'themes' in data && 'default' in data) {
         return { status: 'valid', config: data as ThemeConfig, filePath };
       }
-      return { status: 'invalid', config: this.getMinimalConfig(), error: 'Invalid structure: missing "themes" or "default" property', filePath };
+      return {
+        status: 'invalid',
+        config: this.getMinimalConfig(),
+        error: 'Invalid structure: missing "themes" or "default" property',
+        filePath,
+      };
     } catch (error) {
       return {
         status: 'invalid',
@@ -149,7 +157,7 @@ export class ColorService extends CachedConfigLoader<ThemeConfig> {
     const config = await this.loadThemeConfig();
     const theme = themeName && config.themes[themeName] ? config.themes[themeName] : config.themes[config.default];
     const resolvedColors: Record<string, string> = {};
-    for (const [name, value] of Object.entries(theme.colors)) {
+    for (const [name, value] of Object.entries(theme?.colors ?? {})) {
       resolvedColors[name] = resolvePaletteColor(value, config.palette);
     }
     return { colors: resolvedColors };

package/lib/server/services/EnumService.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { join } from 'path';
-import { mkdirSync, rmSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
 import { setProjectRoot, getProjectRoot } from '../projectContext';
 import { EnumService } from './EnumService';
 import type { EnumsConfig } from '../../shared/types';
@@ -68,11 +68,7 @@ describe('EnumService', () => {
 
     test('deduplicates concurrent calls', async () => {
       writeEnums(VALID_CONFIG);
-      const [a, b, c] = await Promise.all([
-        service.loadConfig(),
-        service.loadConfig(),
-        service.loadConfig(),
-      ]);
+      const [a, b, c] = await Promise.all([service.loadConfig(), service.loadConfig(), service.loadConfig()]);
       expect(a).toBe(b);
       expect(b).toBe(c);
     });
@@ -94,7 +90,7 @@ describe('EnumService', () => {
           invalid_number: [1, 2, 3],
           invalid_mixed: ['a', 1],
           invalid_string: 'not-array',
-        })
+        }),
       );
       const config = await service.loadConfig();
       expect(config.valid).toEqual(['a', 'b']);

package/lib/server/services/EnumService.ts

@@ -8,6 +8,9 @@ import { projectPaths } from '../projectContext';
 import type { EnumsConfig } from '../../shared/types';
 import { CachedConfigLoader } from './CachedConfigLoader';
 import { writeFile } from '../runtime';
+import { createLogger } from '../../shared/logger';
+
+const log = createLogger('EnumService');
 
 export class EnumService extends CachedConfigLoader<EnumsConfig> {
   /**
@@ -32,7 +35,7 @@ export class EnumService extends CachedConfigLoader<EnumsConfig> {
           return this.validateEnums(data as Record<string, unknown>);
         }
       } catch (error) {
-        console.warn('Failed to parse enums.json:', error);
+        log.warn('Failed to parse enums.json:', error);
       }
     }
 
@@ -64,7 +67,7 @@ export class EnumService extends CachedConfigLoader<EnumsConfig> {
   private validateEnums(data: Record<string, unknown>): EnumsConfig {
     const result: Record<string, string[]> = {};
     for (const [key, value] of Object.entries(data)) {
-      if (Array.isArray(value) && value.every(item => typeof item === 'string')) {
+      if (Array.isArray(value) && value.every((item) => typeof item === 'string')) {
         result[key] = value;
       }
     }
@@ -97,7 +100,12 @@ export class EnumService extends CachedConfigLoader<EnumsConfig> {
       if (data && typeof data === 'object' && !Array.isArray(data)) {
         return { status: 'valid', config: this.validateEnums(data as Record<string, unknown>), filePath };
       }
-      return { status: 'invalid', config: this.getDefaultConfig(), error: 'Invalid structure: expected Record<string, string[]>', filePath };
+      return {
+        status: 'invalid',
+        config: this.getDefaultConfig(),
+        error: 'Invalid structure: expected Record<string, string[]>',
+        filePath,
+      };
     } catch (error) {
       return {
         status: 'invalid',

package/lib/server/services/VariableService.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { join } from 'path';
-import { mkdirSync, rmSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
 import { setProjectRoot, getProjectRoot } from '../projectContext';
 import { VariableService } from './VariableService';
 import type { VariablesConfig } from '../../shared/types';
@@ -47,7 +47,7 @@ describe('VariableService', () => {
       writeVariables(VALID_CONFIG);
       const config = await service.loadConfig();
       expect(config.variables).toHaveLength(2);
-      expect(config.variables[0].name).toBe('heading-size');
+      expect(config.variables[0]!.name).toBe('heading-size');
     });
 
     test('returns defaults when file missing', async () => {
@@ -67,11 +67,7 @@ describe('VariableService', () => {
 
     test('deduplicates concurrent calls', async () => {
       writeVariables(VALID_CONFIG);
-      const [a, b, c] = await Promise.all([
-        service.loadConfig(),
-        service.loadConfig(),
-        service.loadConfig(),
-      ]);
+      const [a, b, c] = await Promise.all([service.loadConfig(), service.loadConfig(), service.loadConfig()]);
       expect(a).toBe(b);
       expect(b).toBe(c);
     });
@@ -92,9 +88,9 @@ describe('VariableService', () => {
       };
       writeVariables(legacyConfig);
       const config = await service.loadConfig();
-      expect(config.variables[0].group).toBe('margin');
-      expect(config.variables[1].group).toBe('gap');
-      expect(config.variables[2].group).toBe('padding'); // default fallback
+      expect(config.variables[0]!.group).toBe('margin');
+      expect(config.variables[1]!.group).toBe('gap');
+      expect(config.variables[2]!.group).toBe('padding'); // default fallback
     });
   });
 
@@ -177,7 +173,7 @@ describe('VariableService', () => {
       writeVariables(legacyConfig);
       const result = await service.getConfigWithStatus();
       expect(result.status).toBe('valid');
-      expect(result.config.variables[0].group).toBe('margin');
+      expect(result.config.variables[0]!.group).toBe('margin');
     });
   });
 });

package/lib/server/services/VariableService.ts

@@ -8,6 +8,9 @@ import { projectPaths } from '../projectContext';
 import type { VariablesConfig } from '../../shared/types';
 import { CachedConfigLoader } from './CachedConfigLoader';
 import { writeFile } from '../runtime';
+import { createLogger } from '../../shared/logger';
+
+const log = createLogger('VariableService');
 
 export class VariableService extends CachedConfigLoader<VariablesConfig> {
   /**
@@ -27,7 +30,7 @@ export class VariableService extends CachedConfigLoader<VariablesConfig> {
         }
       }
     } catch (error) {
-      console.warn('Failed to load variables.json:', error);
+      log.warn('Failed to load variables.json:', error);
     }
 
     return this.getDefaultConfig();
@@ -43,7 +46,7 @@ export class VariableService extends CachedConfigLoader<VariablesConfig> {
   private migrateConfig(config: VariablesConfig): VariablesConfig {
     for (const variable of config.variables) {
       if ((variable.group as string) === 'spacing') {
-        const lower = (variable.cssVar + ' ' + variable.name).toLowerCase();
+        const lower = `${variable.cssVar} ${variable.name}`.toLowerCase();
         if (lower.includes('margin')) {
           variable.group = 'margin';
         } else if (lower.includes('gap')) {
@@ -75,7 +78,12 @@ export class VariableService extends CachedConfigLoader<VariablesConfig> {
       if (data && typeof data === 'object' && 'variables' in data && Array.isArray(data.variables)) {
         return { status: 'valid', config: this.migrateConfig(data as VariablesConfig), filePath };
       }
-      return { status: 'invalid', config: this.getDefaultConfig(), error: 'Invalid structure: missing "variables" array', filePath };
+      return {
+        status: 'invalid',
+        config: this.getDefaultConfig(),
+        error: 'Invalid structure: missing "variables" array',
+        filePath,
+      };
     } catch (error) {
       return {
         status: 'invalid',