meno-core 1.0.21 → 1.0.23

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

@@ -0,0 +1,950 @@
+import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { join } from 'path';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'fs';
+
+// We need to mock projectPaths.config() before importing ConfigService.
+// Since projectPaths is a module-level export, we mock the projectContext module.
+import { setProjectRoot, getProjectRoot } from '../../server/projectContext';
+import { ConfigService } from './configService';
+import type { IconsConfig, EnumsConfig } from './configService';
+import { DEFAULT_BREAKPOINTS } from '../../shared/breakpoints';
+import { DEFAULT_RESPONSIVE_SCALES } from '../../shared/responsiveScaling';
+import { DEFAULT_I18N_CONFIG } from '../../shared/i18n';
+
+// Use a unique temp directory for each test run
+const TEST_DIR = join('/tmp', `configService-test-${process.pid}`);
+const CONFIG_PATH = join(TEST_DIR, 'project.config.json');
+
+function writeConfig(config: Record<string, unknown>): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function removeConfig(): void {
+  if (existsSync(CONFIG_PATH)) {
+    rmSync(CONFIG_PATH);
+  }
+}
+
+describe('ConfigService', () => {
+  let service: ConfigService;
+  let originalRoot: string;
+
+  beforeEach(() => {
+    // Save original project root and set to our temp dir
+    originalRoot = getProjectRoot();
+    mkdirSync(TEST_DIR, { recursive: true });
+    setProjectRoot(TEST_DIR);
+    service = new ConfigService();
+  });
+
+  afterEach(() => {
+    // Restore original project root and clean up temp files
+    setProjectRoot(originalRoot);
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  // =========================================================
+  // load()
+  // =========================================================
+  describe('load()', () => {
+    test('should load config from file', async () => {
+      writeConfig({ icons: { favicon: '/favicon.ico' } });
+
+      await service.load();
+
+      expect(service.isLoaded()).toBe(true);
+      expect(service.getIcons()).toEqual({ favicon: '/favicon.ico' });
+    });
+
+    test('should return defaults when file does not exist', async () => {
+      // No config file written
+      removeConfig();
+
+      await service.load();
+
+      expect(service.isLoaded()).toBe(true);
+      // All getters should return defaults
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+      expect(service.getIcons()).toEqual({});
+      expect(service.getLibraries()).toEqual({ js: [], css: [] });
+    });
+
+    test('should only load once (idempotent)', async () => {
+      writeConfig({ icons: { favicon: '/first.ico' } });
+      await service.load();
+      expect(service.getIcons()).toEqual({ favicon: '/first.ico' });
+
+      // Overwrite the file with different content
+      writeConfig({ icons: { favicon: '/second.ico' } });
+      await service.load(); // Should not reload
+
+      // Still returns the first value since it was already loaded
+      expect(service.getIcons()).toEqual({ favicon: '/first.ico' });
+    });
+
+    test('should handle invalid JSON gracefully', async () => {
+      writeFileSync(CONFIG_PATH, '{ not valid json !!!');
+
+      await service.load();
+
+      expect(service.isLoaded()).toBe(true);
+      // Falls back to defaults
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+      expect(service.getIcons()).toEqual({});
+    });
+  });
+
+  // =========================================================
+  // isLoaded() / reset()
+  // =========================================================
+  describe('isLoaded()', () => {
+    test('should return false before load', () => {
+      expect(service.isLoaded()).toBe(false);
+    });
+
+    test('should return true after load', async () => {
+      removeConfig();
+      await service.load();
+      expect(service.isLoaded()).toBe(true);
+    });
+  });
+
+  describe('reset()', () => {
+    test('should clear loaded state', async () => {
+      writeConfig({ icons: { favicon: '/test.ico' } });
+      await service.load();
+      expect(service.isLoaded()).toBe(true);
+
+      service.reset();
+
+      expect(service.isLoaded()).toBe(false);
+    });
+
+    test('should allow reloading after reset', async () => {
+      writeConfig({ icons: { favicon: '/first.ico' } });
+      await service.load();
+      expect(service.getIcons()).toEqual({ favicon: '/first.ico' });
+
+      service.reset();
+
+      // Write new config and reload
+      writeConfig({ icons: { favicon: '/second.ico' } });
+      await service.load();
+      expect(service.getIcons()).toEqual({ favicon: '/second.ico' });
+    });
+
+    test('should clear config data so getters return defaults', async () => {
+      writeConfig({ icons: { favicon: '/test.ico' } });
+      await service.load();
+      expect(service.getIcons()).toEqual({ favicon: '/test.ico' });
+
+      service.reset();
+
+      // After reset, config is null so getters should return defaults
+      expect(service.getIcons()).toEqual({});
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+    });
+  });
+
+  // =========================================================
+  // getBreakpoints()
+  // =========================================================
+  describe('getBreakpoints()', () => {
+    test('should return DEFAULT_BREAKPOINTS when no config', async () => {
+      removeConfig();
+      await service.load();
+
+      const result = service.getBreakpoints();
+      expect(result).toEqual({ ...DEFAULT_BREAKPOINTS });
+    });
+
+    test('should return DEFAULT_BREAKPOINTS when breakpoints is not an object', async () => {
+      writeConfig({ breakpoints: 'not-an-object' });
+      await service.load();
+
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+    });
+
+    test('should return DEFAULT_BREAKPOINTS when breakpoints is null', async () => {
+      writeConfig({ breakpoints: null });
+      await service.load();
+
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+    });
+
+    test('should normalize legacy number format to object format', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: 1024,
+          mobile: 540,
+        },
+      });
+      await service.load();
+
+      const result = service.getBreakpoints();
+      expect(result.tablet).toEqual({ breakpoint: 1024, previewPoint: 1024 });
+      expect(result.mobile).toEqual({ breakpoint: 540, previewPoint: 540 });
+    });
+
+    test('should return breakpoints from new object format', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: { breakpoint: 1024, previewPoint: 768 },
+          mobile: { breakpoint: 540, previewPoint: 375 },
+        },
+      });
+      await service.load();
+
+      const result = service.getBreakpoints();
+      expect(result.tablet).toEqual({ breakpoint: 1024, previewPoint: 768 });
+      expect(result.mobile).toEqual({ breakpoint: 540, previewPoint: 375 });
+    });
+
+    test('should default previewPoint to breakpoint value when not specified in object format', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: { breakpoint: 1024 },
+        },
+      });
+      await service.load();
+
+      const result = service.getBreakpoints();
+      expect(result.tablet.breakpoint).toBe(1024);
+      expect(result.tablet.previewPoint).toBe(1024);
+    });
+
+    test('should fall back to defaults for non-positive number values', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: 0,
+          mobile: -100,
+        },
+      });
+      await service.load();
+
+      // All values are invalid, so should return defaults
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+    });
+
+    test('should fall back to defaults for non-number values in legacy format', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: 'not-a-number',
+          mobile: true,
+        },
+      });
+      await service.load();
+
+      // None are valid numbers or objects with valid breakpoint, so defaults
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+    });
+
+    test('should filter out invalid entries but keep valid ones', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: 1024,
+          invalid: -5,
+          alsoInvalid: 'bad',
+          mobile: { breakpoint: 540, previewPoint: 375 },
+        },
+      });
+      await service.load();
+
+      const result = service.getBreakpoints();
+      expect(result.tablet).toEqual({ breakpoint: 1024, previewPoint: 1024 });
+      expect(result.mobile).toEqual({ breakpoint: 540, previewPoint: 375 });
+      expect(result.invalid).toBeUndefined();
+      expect(result.alsoInvalid).toBeUndefined();
+    });
+
+    test('should ignore object entries with non-positive breakpoint value', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: { breakpoint: -10, previewPoint: 768 },
+        },
+      });
+      await service.load();
+
+      // No valid entries, returns defaults
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+    });
+
+    test('should fall back previewPoint to breakpoint when previewPoint is non-positive', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: { breakpoint: 1024, previewPoint: -5 },
+        },
+      });
+      await service.load();
+
+      const result = service.getBreakpoints();
+      expect(result.tablet.previewPoint).toBe(1024);
+    });
+
+    test('should support custom breakpoint names', async () => {
+      writeConfig({
+        breakpoints: {
+          tabletLandscape: 1200,
+          tabletPortrait: 900,
+          phoneLarge: 600,
+          phoneSmall: 375,
+        },
+      });
+      await service.load();
+
+      const result = service.getBreakpoints();
+      expect(Object.keys(result)).toHaveLength(4);
+      expect(result.tabletLandscape).toEqual({ breakpoint: 1200, previewPoint: 1200 });
+      expect(result.phoneSmall).toEqual({ breakpoint: 375, previewPoint: 375 });
+    });
+  });
+
+  // =========================================================
+  // getI18n()
+  // =========================================================
+  describe('getI18n()', () => {
+    test('should return DEFAULT_I18N_CONFIG when no config', async () => {
+      removeConfig();
+      await service.load();
+
+      expect(service.getI18n()).toEqual({ ...DEFAULT_I18N_CONFIG });
+    });
+
+    test('should return DEFAULT_I18N_CONFIG when i18n is not set', async () => {
+      writeConfig({});
+      await service.load();
+
+      expect(service.getI18n()).toEqual({ ...DEFAULT_I18N_CONFIG });
+    });
+
+    test('should migrate old string[] locale format', async () => {
+      writeConfig({
+        i18n: {
+          defaultLocale: 'en',
+          locales: ['en', 'pl'],
+        },
+      });
+      await service.load();
+
+      const result = service.getI18n();
+      expect(result.defaultLocale).toBe('en');
+      expect(result.locales).toHaveLength(2);
+      expect(result.locales[0].code).toBe('en');
+      expect(result.locales[1].code).toBe('pl');
+      // Migrated locales should have name, nativeName, langTag
+      expect(result.locales[1].name).toBe('PL');
+      expect(result.locales[1].nativeName).toBe('PL');
+      expect(result.locales[1].langTag).toBe('pl-PL');
+    });
+
+    test('should pass through new LocaleConfig[] format', async () => {
+      writeConfig({
+        i18n: {
+          defaultLocale: 'en',
+          locales: [
+            { code: 'en', name: 'English', nativeName: 'English', langTag: 'en-US' },
+            { code: 'de', name: 'German', nativeName: 'Deutsch', langTag: 'de-DE' },
+          ],
+        },
+      });
+      await service.load();
+
+      const result = service.getI18n();
+      expect(result.defaultLocale).toBe('en');
+      expect(result.locales).toHaveLength(2);
+      expect(result.locales[1]).toEqual({
+        code: 'de',
+        name: 'German',
+        nativeName: 'Deutsch',
+        langTag: 'de-DE',
+      });
+    });
+
+    test('should return default when i18n is a non-object value', async () => {
+      writeConfig({ i18n: 'invalid' });
+      await service.load();
+
+      expect(service.getI18n()).toEqual({ ...DEFAULT_I18N_CONFIG });
+    });
+  });
+
+  // =========================================================
+  // getResponsiveScales()
+  // =========================================================
+  describe('getResponsiveScales()', () => {
+    test('should return defaults when no config', async () => {
+      removeConfig();
+      await service.load();
+
+      expect(service.getResponsiveScales()).toEqual({ ...DEFAULT_RESPONSIVE_SCALES });
+    });
+
+    test('should return defaults when responsiveScales is not an object', async () => {
+      writeConfig({ responsiveScales: 'invalid' });
+      await service.load();
+
+      expect(service.getResponsiveScales()).toEqual({ ...DEFAULT_RESPONSIVE_SCALES });
+    });
+
+    test('should return defaults when responsiveScales is null', async () => {
+      writeConfig({ responsiveScales: null });
+      await service.load();
+
+      expect(service.getResponsiveScales()).toEqual({ ...DEFAULT_RESPONSIVE_SCALES });
+    });
+
+    test('should deep merge user scales with defaults', async () => {
+      writeConfig({
+        responsiveScales: {
+          enabled: true,
+          fontSize: {
+            tablet: 0.9,
+            // mobile should come from defaults
+          },
+        },
+      });
+      await service.load();
+
+      const result = service.getResponsiveScales();
+      expect(result.enabled).toBe(true);
+      expect(result.baseReference).toBe(DEFAULT_RESPONSIVE_SCALES.baseReference);
+      // User-defined tablet should override default
+      expect(result.fontSize!.tablet).toBe(0.9);
+      // Default mobile should be preserved
+      expect(result.fontSize!.mobile).toBe(DEFAULT_RESPONSIVE_SCALES.fontSize!.mobile);
+      // Padding should be fully from defaults
+      expect(result.padding).toEqual(DEFAULT_RESPONSIVE_SCALES.padding);
+    });
+
+    test('should override user baseReference', async () => {
+      writeConfig({
+        responsiveScales: {
+          baseReference: 20,
+        },
+      });
+      await service.load();
+
+      const result = service.getResponsiveScales();
+      expect(result.baseReference).toBe(20);
+    });
+
+    test('should allow user to override all scale categories', async () => {
+      writeConfig({
+        responsiveScales: {
+          enabled: true,
+          baseReference: 14,
+          fontSize: { small: 0.6 },
+          padding: { small: 0.3 },
+          margin: { small: 0.2 },
+          gap: { small: 0.1 },
+        },
+      });
+      await service.load();
+
+      const result = service.getResponsiveScales();
+      expect(result.enabled).toBe(true);
+      expect(result.baseReference).toBe(14);
+      // User custom breakpoint names should be included alongside defaults
+      expect(result.fontSize!.small).toBe(0.6);
+      expect(result.fontSize!.tablet).toBe(DEFAULT_RESPONSIVE_SCALES.fontSize!.tablet);
+      expect(result.padding!.small).toBe(0.3);
+      expect(result.margin!.small).toBe(0.2);
+      expect(result.gap!.small).toBe(0.1);
+    });
+
+    test('should use default enabled when user does not specify', async () => {
+      writeConfig({
+        responsiveScales: {
+          baseReference: 18,
+        },
+      });
+      await service.load();
+
+      const result = service.getResponsiveScales();
+      expect(result.enabled).toBe(DEFAULT_RESPONSIVE_SCALES.enabled);
+    });
+  });
+
+  // =========================================================
+  // getIcons()
+  // =========================================================
+  describe('getIcons()', () => {
+    test('should return empty object when no config', async () => {
+      removeConfig();
+      await service.load();
+
+      expect(service.getIcons()).toEqual({});
+    });
+
+    test('should return empty object when icons is not set', async () => {
+      writeConfig({});
+      await service.load();
+
+      expect(service.getIcons()).toEqual({});
+    });
+
+    test('should return empty object when icons is not an object', async () => {
+      writeConfig({ icons: 'invalid' });
+      await service.load();
+
+      expect(service.getIcons()).toEqual({});
+    });
+
+    test('should return icons object', async () => {
+      writeConfig({
+        icons: {
+          favicon: '/favicon.ico',
+          appleTouchIcon: '/apple-touch-icon.png',
+        },
+      });
+      await service.load();
+
+      expect(service.getIcons()).toEqual({
+        favicon: '/favicon.ico',
+        appleTouchIcon: '/apple-touch-icon.png',
+      });
+    });
+
+    test('should return partial icons config', async () => {
+      writeConfig({
+        icons: {
+          favicon: '/custom-favicon.svg',
+        },
+      });
+      await service.load();
+
+      const result = service.getIcons();
+      expect(result.favicon).toBe('/custom-favicon.svg');
+      expect(result.appleTouchIcon).toBeUndefined();
+    });
+  });
+
+  // =========================================================
+  // getLibraries()
+  // =========================================================
+  describe('getLibraries()', () => {
+    test('should return empty arrays when no config', async () => {
+      removeConfig();
+      await service.load();
+
+      expect(service.getLibraries()).toEqual({ js: [], css: [] });
+    });
+
+    test('should return empty arrays when libraries is not set', async () => {
+      writeConfig({});
+      await service.load();
+
+      expect(service.getLibraries()).toEqual({ js: [], css: [] });
+    });
+
+    test('should return empty arrays when libraries is not an object', async () => {
+      writeConfig({ libraries: 'invalid' });
+      await service.load();
+
+      expect(service.getLibraries()).toEqual({ js: [], css: [] });
+    });
+
+    test('should normalize string URLs to object format for JS libraries', async () => {
+      writeConfig({
+        libraries: {
+          js: [
+            'https://cdn.example.com/lib.js',
+            'https://cdn.example.com/other.js',
+          ],
+        },
+      });
+      await service.load();
+
+      const result = service.getLibraries();
+      expect(result.js).toEqual([
+        { url: 'https://cdn.example.com/lib.js' },
+        { url: 'https://cdn.example.com/other.js' },
+      ]);
+    });
+
+    test('should normalize string URLs to object format for CSS libraries', async () => {
+      writeConfig({
+        libraries: {
+          css: [
+            'https://fonts.googleapis.com/css2?family=Inter',
+          ],
+        },
+      });
+      await service.load();
+
+      const result = service.getLibraries();
+      expect(result.css).toEqual([
+        { url: 'https://fonts.googleapis.com/css2?family=Inter' },
+      ]);
+    });
+
+    test('should pass through object format for JS libraries', async () => {
+      writeConfig({
+        libraries: {
+          js: [
+            { url: 'https://cdn.example.com/lib.js', mode: 'async', position: 'head' },
+          ],
+        },
+      });
+      await service.load();
+
+      const result = service.getLibraries();
+      expect(result.js).toEqual([
+        { url: 'https://cdn.example.com/lib.js', mode: 'async', position: 'head' },
+      ]);
+    });
+
+    test('should pass through object format for CSS libraries', async () => {
+      writeConfig({
+        libraries: {
+          css: [
+            { url: 'https://fonts.googleapis.com/style.css', media: 'screen' },
+          ],
+        },
+      });
+      await service.load();
+
+      const result = service.getLibraries();
+      expect(result.css).toEqual([
+        { url: 'https://fonts.googleapis.com/style.css', media: 'screen' },
+      ]);
+    });
+
+    test('should handle mixed string and object formats', async () => {
+      writeConfig({
+        libraries: {
+          js: [
+            'https://cdn.example.com/simple.js',
+            { url: 'https://cdn.example.com/complex.js', mode: 'defer' },
+          ],
+          css: [
+            'https://cdn.example.com/simple.css',
+            { url: 'https://cdn.example.com/complex.css', media: 'print' },
+          ],
+        },
+      });
+      await service.load();
+
+      const result = service.getLibraries();
+      expect(result.js).toHaveLength(2);
+      expect(result.js![0]).toEqual({ url: 'https://cdn.example.com/simple.js' });
+      expect(result.js![1]).toEqual({ url: 'https://cdn.example.com/complex.js', mode: 'defer' });
+      expect(result.css).toHaveLength(2);
+      expect(result.css![0]).toEqual({ url: 'https://cdn.example.com/simple.css' });
+      expect(result.css![1]).toEqual({ url: 'https://cdn.example.com/complex.css', media: 'print' });
+    });
+
+    test('should return empty array when js or css is not an array', async () => {
+      writeConfig({
+        libraries: {
+          js: 'not-an-array',
+          css: 42,
+        },
+      });
+      await service.load();
+
+      const result = service.getLibraries();
+      expect(result.js).toEqual([]);
+      expect(result.css).toEqual([]);
+    });
+
+    test('should handle missing js or css keys', async () => {
+      writeConfig({
+        libraries: {
+          js: [{ url: 'https://example.com/lib.js' }],
+          // css not specified
+        },
+      });
+      await service.load();
+
+      const result = service.getLibraries();
+      expect(result.js).toHaveLength(1);
+      expect(result.css).toEqual([]);
+    });
+  });
+
+  // =========================================================
+  // getCSP()
+  // =========================================================
+  describe('getCSP()', () => {
+    test('should return empty object when no config', async () => {
+      removeConfig();
+      await service.load();
+
+      expect(service.getCSP()).toEqual({});
+    });
+
+    test('should return empty object when csp is not set', async () => {
+      writeConfig({});
+      await service.load();
+
+      expect(service.getCSP()).toEqual({});
+    });
+
+    test('should return empty object when csp is not an object', async () => {
+      writeConfig({ csp: 'invalid' });
+      await service.load();
+
+      expect(service.getCSP()).toEqual({});
+    });
+
+    test('should return CSP config', async () => {
+      writeConfig({
+        csp: {
+          scriptSrc: ['https://cdnjs.cloudflare.com', 'https://unpkg.com'],
+          styleSrc: ['https://fonts.googleapis.com'],
+          connectSrc: ['https://api.example.com'],
+        },
+      });
+      await service.load();
+
+      const result = service.getCSP();
+      expect(result.scriptSrc).toEqual(['https://cdnjs.cloudflare.com', 'https://unpkg.com']);
+      expect(result.styleSrc).toEqual(['https://fonts.googleapis.com']);
+      expect(result.connectSrc).toEqual(['https://api.example.com']);
+    });
+
+    test('should return partial CSP config', async () => {
+      writeConfig({
+        csp: {
+          imgSrc: ['https://images.example.com'],
+        },
+      });
+      await service.load();
+
+      const result = service.getCSP();
+      expect(result.imgSrc).toEqual(['https://images.example.com']);
+      expect(result.scriptSrc).toBeUndefined();
+    });
+  });
+
+  // =========================================================
+  // getEnums()
+  // =========================================================
+  describe('getEnums()', () => {
+    test('should return empty object when no config', async () => {
+      removeConfig();
+      await service.load();
+
+      expect(service.getEnums()).toEqual({});
+    });
+
+    test('should return empty object when enums is not set', async () => {
+      writeConfig({});
+      await service.load();
+
+      expect(service.getEnums()).toEqual({});
+    });
+
+    test('should return empty object when enums is not an object', async () => {
+      writeConfig({ enums: 'invalid' });
+      await service.load();
+
+      expect(service.getEnums()).toEqual({});
+    });
+
+    test('should return valid string array enums', async () => {
+      writeConfig({
+        enums: {
+          colors: ['red', 'green', 'blue'],
+          sizes: ['sm', 'md', 'lg', 'xl'],
+        },
+      });
+      await service.load();
+
+      const result = service.getEnums();
+      expect(result.colors).toEqual(['red', 'green', 'blue']);
+      expect(result.sizes).toEqual(['sm', 'md', 'lg', 'xl']);
+    });
+
+    test('should filter out non-string-array values', async () => {
+      writeConfig({
+        enums: {
+          validEnum: ['a', 'b', 'c'],
+          numberArray: [1, 2, 3],
+          mixedArray: ['a', 1, 'b'],
+          notAnArray: 'just a string',
+          nullValue: null,
+          objectValue: { key: 'value' },
+        },
+      });
+      await service.load();
+
+      const result = service.getEnums();
+      expect(result.validEnum).toEqual(['a', 'b', 'c']);
+      expect(result.numberArray).toBeUndefined();
+      expect(result.mixedArray).toBeUndefined();
+      expect(result.notAnArray).toBeUndefined();
+      expect(result.nullValue).toBeUndefined();
+      expect(result.objectValue).toBeUndefined();
+    });
+
+    test('should return empty object when all enum values are invalid', async () => {
+      writeConfig({
+        enums: {
+          numbers: [1, 2, 3],
+          booleans: [true, false],
+        },
+      });
+      await service.load();
+
+      expect(service.getEnums()).toEqual({});
+    });
+
+    test('should handle empty string arrays', async () => {
+      writeConfig({
+        enums: {
+          emptyEnum: [],
+        },
+      });
+      await service.load();
+
+      const result = service.getEnums();
+      // Empty array is a valid string array (vacuously true)
+      expect(result.emptyEnum).toEqual([]);
+    });
+  });
+
+  // =========================================================
+  // getRaw()
+  // =========================================================
+  describe('getRaw()', () => {
+    test('should return undefined when config not loaded', () => {
+      // Service not loaded yet
+      expect(service.getRaw('anything')).toBeUndefined();
+    });
+
+    test('should return undefined when config file does not exist', async () => {
+      removeConfig();
+      await service.load();
+
+      expect(service.getRaw('anything')).toBeUndefined();
+    });
+
+    test('should return undefined for non-existent key', async () => {
+      writeConfig({ icons: { favicon: '/test.ico' } });
+      await service.load();
+
+      expect(service.getRaw('nonExistentKey')).toBeUndefined();
+    });
+
+    test('should return raw value by key', async () => {
+      writeConfig({
+        icons: { favicon: '/test.ico' },
+        customKey: 'customValue',
+        nestedConfig: { deep: { value: 42 } },
+      });
+      await service.load();
+
+      expect(service.getRaw<string>('customKey')).toBe('customValue');
+      expect(service.getRaw<{ deep: { value: number } }>('nestedConfig')).toEqual({
+        deep: { value: 42 },
+      });
+    });
+
+    test('should return raw breakpoints without normalization', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: 1024,
+        },
+      });
+      await service.load();
+
+      // getRaw returns the raw value, not the normalized one
+      const raw = service.getRaw<Record<string, number>>('breakpoints');
+      expect(raw).toEqual({ tablet: 1024 });
+    });
+  });
+
+  // =========================================================
+  // Integration / combined behavior
+  // =========================================================
+  describe('integration', () => {
+    test('should handle a full project.config.json', async () => {
+      writeConfig({
+        breakpoints: {
+          tablet: { breakpoint: 1024, previewPoint: 768 },
+          mobile: { breakpoint: 540, previewPoint: 375 },
+        },
+        responsiveScales: {
+          enabled: true,
+          baseReference: 16,
+          fontSize: { tablet: 0.9, mobile: 0.8 },
+        },
+        i18n: {
+          defaultLocale: 'en',
+          locales: [
+            { code: 'en', name: 'English', nativeName: 'English', langTag: 'en-US' },
+            { code: 'pl', name: 'Polish', nativeName: 'Polski', langTag: 'pl-PL' },
+          ],
+        },
+        icons: {
+          favicon: '/favicon.svg',
+          appleTouchIcon: '/apple-icon.png',
+        },
+        libraries: {
+          js: [{ url: 'https://cdn.example.com/app.js', mode: 'defer' }],
+          css: ['https://fonts.googleapis.com/css?family=Inter'],
+        },
+        csp: {
+          scriptSrc: ['https://cdn.example.com'],
+        },
+        enums: {
+          status: ['active', 'inactive', 'pending'],
+        },
+      });
+      await service.load();
+
+      // Verify all getters work correctly together
+      const breakpoints = service.getBreakpoints();
+      expect(breakpoints.tablet.breakpoint).toBe(1024);
+      expect(breakpoints.mobile.previewPoint).toBe(375);
+
+      const scales = service.getResponsiveScales();
+      expect(scales.enabled).toBe(true);
+      expect(scales.fontSize!.tablet).toBe(0.9);
+
+      const i18n = service.getI18n();
+      expect(i18n.locales).toHaveLength(2);
+
+      const icons = service.getIcons();
+      expect(icons.favicon).toBe('/favicon.svg');
+
+      const libs = service.getLibraries();
+      expect(libs.js).toHaveLength(1);
+      expect(libs.css).toHaveLength(1);
+      expect(libs.css![0]).toEqual({ url: 'https://fonts.googleapis.com/css?family=Inter' });
+
+      const csp = service.getCSP();
+      expect(csp.scriptSrc).toEqual(['https://cdn.example.com']);
+
+      const enums = service.getEnums();
+      expect(enums.status).toEqual(['active', 'inactive', 'pending']);
+    });
+
+    test('should handle empty config object', async () => {
+      writeConfig({});
+      await service.load();
+
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+      expect(service.getI18n()).toEqual({ ...DEFAULT_I18N_CONFIG });
+      expect(service.getResponsiveScales()).toEqual({ ...DEFAULT_RESPONSIVE_SCALES });
+      expect(service.getIcons()).toEqual({});
+      expect(service.getLibraries()).toEqual({ js: [], css: [] });
+      expect(service.getCSP()).toEqual({});
+      expect(service.getEnums()).toEqual({});
+    });
+
+    test('getters should work before load (returning defaults)', () => {
+      // Without calling load(), config is null
+      expect(service.getBreakpoints()).toEqual({ ...DEFAULT_BREAKPOINTS });
+      expect(service.getI18n()).toEqual({ ...DEFAULT_I18N_CONFIG });
+      expect(service.getResponsiveScales()).toEqual({ ...DEFAULT_RESPONSIVE_SCALES });
+      expect(service.getIcons()).toEqual({});
+      expect(service.getLibraries()).toEqual({ js: [], css: [] });
+      expect(service.getCSP()).toEqual({});
+      expect(service.getEnums()).toEqual({});
+      expect(service.getRaw('anything')).toBeUndefined();
+    });
+  });
+});