@jmruthers/pace-core 0.5.68 → 0.5.69

package/src/services/interfaces/IOrganisationService.ts

@@ -0,0 +1,41 @@
+/**
+ * @file Organisation Service Interface
+ * @package @jmruthers/pace-core
+ * @module Services/Interfaces
+ * @since 0.1.0
+ *
+ * Interface for organisation service operations.
+ * Defines the contract for organisation management functionality.
+ */
+
+import type {
+  Organisation,
+  OrganisationMembership,
+  OrganisationSecurityError,
+  OrganisationHierarchy
+} from '../../types/organisation';
+
+export interface IOrganisationService {
+  // Organisation state
+  getSelectedOrganisation(): Organisation | null;
+  getOrganisations(): Organisation[];
+  getUserMemberships(): OrganisationMembership[];
+  isLoading(): boolean;
+  getError(): Error | null;
+  hasValidOrganisationContext(): boolean;
+  isContextReady(): boolean;
+
+  // Organisation methods
+  switchOrganisation(orgId: string): Promise<void>;
+  getUserRole(orgId?: string): string;
+  validateOrganisationAccess(orgId: string): boolean;
+  refreshOrganisations(): Promise<void>;
+  ensureOrganisationContext(): Organisation;
+  isOrganisationSecure(): boolean;
+  getPrimaryOrganisation(): Organisation | null;
+  buildOrganisationHierarchy(orgs: Organisation[]): OrganisationHierarchy[];
+
+  // Lifecycle
+  initialize(): Promise<void>;
+  cleanup(): void;
+}

package/src/services/interfaces/IRBACService.ts

@@ -0,0 +1,62 @@
+/**
+ * @file RBAC Service Interface
+ * @package @jmruthers/pace-core
+ * @module Services/Interfaces
+ * @since 0.1.0
+ *
+ * Interface for RBAC service operations.
+ * Defines the contract for role-based access control functionality.
+ */
+
+import { AccessLevel } from '../../types/unified';
+
+export interface UserEventAccess {
+  event_id: string;
+  event_name: string;
+  event_description?: string | null;
+  start_date: string;
+  end_date: string;
+  event_status: string;
+  app_id: string;
+  access_level: string;
+  granted_at: string;
+  organisation_id: string;
+}
+
+export interface AppConfig {
+  supports_direct_access: boolean;
+  requires_event: boolean;
+}
+
+export interface IRBACService {
+  // RBAC state
+  getPermissions(): Record<string, boolean>;
+  getRoles(): string[];
+  getAccessLevel(): AccessLevel;
+  isLoading(): boolean;
+  getError(): Error | null;
+  getSelectedEventId(): string | null;
+  getAppConfig(): AppConfig | null;
+  getUserEventAccess(): UserEventAccess[];
+  isEventAccessLoading(): boolean;
+  getSelectedOrganisationId(): string | null;
+
+  // RBAC methods
+  hasPermission(permission: string, orgId?: string): boolean;
+  hasAnyPermission(permissions: string[], orgId?: string): boolean;
+  hasAllPermissions(permissions: string[], orgId?: string): boolean;
+  hasRole(role: string): boolean;
+  hasAccessLevel(level: AccessLevel): boolean;
+  canAccess(resource: string, action: string, orgId?: string): boolean;
+  validatePermission(permission: string, orgId?: string): Promise<boolean>;
+  validateAccess(resource: string, action: string, orgId?: string): Promise<boolean>;
+  refreshPermissions(eventId?: string, orgId?: string): Promise<void>;
+  setSelectedEventId(eventId: string | null): void;
+  loadUserEventAccess(orgId?: string): Promise<void>;
+  getUserEventAccessById(eventId: string): UserEventAccess | undefined;
+  requireOrganisationContext(): string;
+
+  // Lifecycle
+  initialize(): Promise<void>;
+  cleanup(): void;
+}

package/src/theming/__tests__/runtime.test.ts

@@ -0,0 +1,540 @@
+/**
+ * @file Theming Runtime Tests
+ * @package @jmruthers/pace-core
+ * @module Theming/__tests__
+ * @since 2.0.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  applyPalette,
+  clearPalette,
+  generateSSRThemeCSS,
+  isDynamicThemingActive,
+  getCurrentThemeData,
+  type ColorShade,
+  type ColorPalette,
+  type PaletteData
+} from '../runtime';
+
+// Mock document and console
+const mockDocument = {
+  createElement: vi.fn(),
+  getElementById: vi.fn(),
+  head: {
+    appendChild: vi.fn()
+  }
+};
+
+const mockConsole = {
+  warn: vi.fn()
+};
+
+// Mock global objects
+Object.defineProperty(global, 'document', {
+  value: mockDocument,
+  writable: true
+});
+
+Object.defineProperty(global, 'console', {
+  value: mockConsole,
+  writable: true
+});
+
+describe('[theming] applyPalette', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockDocument.getElementById.mockReturnValue(null);
+  });
+
+    it('applies palette to document', () => {
+    const mockStyle = {
+      id: '',
+      textContent: ''
+    };
+    mockDocument.createElement.mockReturnValue(mockStyle);
+
+    const palette: PaletteData = {
+      main: {
+        50: { L: 0.95, C: 0.02, H: 0 },
+        500: { L: 0.5, C: 0.2, H: 0 }
+      },
+      sec: {
+        50: { L: 0.95, C: 0.02, H: 120 },
+        500: { L: 0.5, C: 0.2, H: 120 }
+      },
+      acc: {
+        50: { L: 0.95, C: 0.02, H: 240 },
+        500: { L: 0.5, C: 0.2, H: 240 }
+      }
+    };
+
+    applyPalette(palette);
+
+    expect(mockDocument.createElement).toHaveBeenCalledWith('style');
+    expect(mockDocument.head.appendChild).toHaveBeenCalled();
+  });
+
+  it('clears existing palette before applying new one', () => {
+    const existingStyle = { remove: vi.fn() };
+    const mockStyle = {
+      id: '',
+      textContent: ''
+    };
+    mockDocument.getElementById.mockReturnValue(existingStyle);
+    mockDocument.createElement.mockReturnValue(mockStyle);
+
+    const palette: PaletteData = {
+      main: { 500: { L: 0.5, C: 0.2, H: 0 } },
+      sec: { 500: { L: 0.5, C: 0.2, H: 120 } },
+      acc: { 500: { L: 0.5, C: 0.2, H: 240 } }
+    };
+
+    applyPalette(palette);
+
+    expect(mockDocument.getElementById).toHaveBeenCalledWith('pace-theme-dynamic');
+    expect(existingStyle.remove).toHaveBeenCalled();
+  });
+
+  it('handles SSR environment gracefully', () => {
+    // Mock SSR environment
+    Object.defineProperty(global, 'document', {
+      value: undefined,
+      writable: true
+    });
+
+    const palette: PaletteData = {
+      main: { 500: { L: 0.5, C: 0.2, H: 0 } },
+      sec: { 500: { L: 0.5, C: 0.2, H: 120 } },
+      acc: { 500: { L: 0.5, C: 0.2, H: 240 } }
+    };
+
+    expect(() => applyPalette(palette)).not.toThrow();
+    expect(mockConsole.warn).toHaveBeenCalledWith('applyPalette: Document not available (SSR)');
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+
+  it('handles null document gracefully', () => {
+    // Mock null document
+    Object.defineProperty(global, 'document', {
+      value: null,
+      writable: true
+    });
+
+    const palette: PaletteData = {
+      main: { 500: { L: 0.5, C: 0.2, H: 0 } },
+      sec: { 500: { L: 0.5, C: 0.2, H: 120 } },
+      acc: { 500: { L: 0.5, C: 0.2, H: 240 } }
+    };
+
+    expect(() => applyPalette(palette)).not.toThrow();
+    expect(mockConsole.warn).toHaveBeenCalledWith('applyPalette: Document not available (SSR)');
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+
+  it('generates correct CSS content', () => {
+    const palette: PaletteData = {
+      main: {
+        50: { L: 0.95, C: 0.02, H: 0 },
+        500: { L: 0.5, C: 0.2, H: 0 }
+      },
+      sec: {
+        50: { L: 0.95, C: 0.02, H: 120 },
+        500: { L: 0.5, C: 0.2, H: 120 }
+      },
+      acc: {
+        50: { L: 0.95, C: 0.02, H: 240 },
+        500: { L: 0.5, C: 0.2, H: 240 }
+      }
+    };
+
+    const mockStyle = {
+      id: '',
+      textContent: ''
+    };
+    mockDocument.createElement.mockReturnValue(mockStyle);
+
+    applyPalette(palette);
+
+    expect(mockStyle.id).toBe('pace-theme-dynamic');
+    expect(mockStyle.textContent).toContain('@theme static {');
+    expect(mockStyle.textContent).toContain('--color-main-50: oklch(0.95 0.02 0)');
+    expect(mockStyle.textContent).toContain('--color-main-500: oklch(0.5 0.2 0)');
+    expect(mockStyle.textContent).toContain('--color-sec-50: oklch(0.95 0.02 120)');
+    expect(mockStyle.textContent).toContain('--color-sec-500: oklch(0.5 0.2 120)');
+    expect(mockStyle.textContent).toContain('--color-acc-50: oklch(0.95 0.02 240)');
+    expect(mockStyle.textContent).toContain('--color-acc-500: oklch(0.5 0.2 240)');
+  });
+
+  it('handles raw color values', () => {
+    const palette: PaletteData = {
+      main: {
+        raw: { L: 0.5, C: 0.2, H: 0 },
+        500: { L: 0.5, C: 0.2, H: 0 }
+      },
+      sec: { 500: { L: 0.5, C: 0.2, H: 120 } },
+      acc: { 500: { L: 0.5, C: 0.2, H: 240 } }
+    };
+
+    const mockStyle = {
+      id: '',
+      textContent: ''
+    };
+    mockDocument.createElement.mockReturnValue(mockStyle);
+
+    applyPalette(palette);
+
+    expect(mockStyle.textContent).toContain('--color-main-raw: oklch(0.5 0.2 0)');
+  });
+
+  it('handles empty palettes gracefully', () => {
+    const palette: PaletteData = {
+      main: {},
+      sec: {},
+      acc: {}
+    };
+
+    const mockStyle = {
+      id: '',
+      textContent: ''
+    };
+    mockDocument.createElement.mockReturnValue(mockStyle);
+
+    expect(() => applyPalette(palette)).not.toThrow();
+    expect(mockStyle.textContent).toContain('@theme static {');
+  });
+});
+
+describe('[theming] clearPalette', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+    it('removes existing dynamic theme block', () => {
+    const existingStyle = { remove: vi.fn() };
+    mockDocument.getElementById.mockReturnValue(existingStyle);
+
+    clearPalette();
+
+    expect(mockDocument.getElementById).toHaveBeenCalledWith('pace-theme-dynamic');
+    expect(existingStyle.remove).toHaveBeenCalled();
+  });
+
+  it('handles no existing theme block', () => {
+    mockDocument.getElementById.mockReturnValue(null);
+
+    expect(() => clearPalette()).not.toThrow();
+  });
+
+  it('handles SSR environment gracefully', () => {
+    // Mock SSR environment
+    Object.defineProperty(global, 'document', {
+      value: undefined,
+      writable: true
+    });
+
+    expect(() => clearPalette()).not.toThrow();
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+
+  it('handles null document gracefully', () => {
+    // Mock null document
+    Object.defineProperty(global, 'document', {
+      value: null,
+      writable: true
+    });
+
+    expect(() => clearPalette()).not.toThrow();
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+});
+
+describe('[theming] generateSSRThemeCSS', () => {
+  it('generates CSS for SSR rendering', () => {
+    const palette: PaletteData = {
+      main: {
+        50: { L: 0.95, C: 0.02, H: 0 },
+        500: { L: 0.5, C: 0.2, H: 0 }
+      },
+      sec: {
+        50: { L: 0.95, C: 0.02, H: 120 },
+        500: { L: 0.5, C: 0.2, H: 120 }
+      },
+      acc: {
+        50: { L: 0.95, C: 0.02, H: 240 },
+        500: { L: 0.5, C: 0.2, H: 240 }
+      }
+    };
+
+    const css = generateSSRThemeCSS(palette);
+
+    expect(css).toContain('@theme static {');
+    expect(css).toContain('--color-main-50: oklch(0.95 0.02 0)');
+    expect(css).toContain('--color-main-500: oklch(0.5 0.2 0)');
+    expect(css).toContain('--color-sec-50: oklch(0.95 0.02 120)');
+    expect(css).toContain('--color-sec-500: oklch(0.5 0.2 120)');
+    expect(css).toContain('--color-acc-50: oklch(0.95 0.02 240)');
+    expect(css).toContain('--color-acc-500: oklch(0.5 0.2 240)');
+  });
+
+  it('throws error for null palette', () => {
+    expect(() => generateSSRThemeCSS(null as any)).toThrow('Palette data is required');
+  });
+
+  it('throws error for undefined palette', () => {
+    expect(() => generateSSRThemeCSS(undefined as any)).toThrow('Palette data is required');
+  });
+});
+
+describe('[theming] isDynamicThemingActive', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+    it('returns true when dynamic theme is active', () => {
+    const existingStyle = { id: 'pace-theme-dynamic' };
+    mockDocument.getElementById.mockReturnValue(existingStyle);
+
+    const isActive = isDynamicThemingActive();
+
+    expect(isActive).toBe(true);
+    expect(mockDocument.getElementById).toHaveBeenCalledWith('pace-theme-dynamic');
+  });
+
+  it('returns false when dynamic theme is not active', () => {
+    mockDocument.getElementById.mockReturnValue(null);
+
+    const isActive = isDynamicThemingActive();
+
+    expect(isActive).toBe(false);
+  });
+
+  it('returns false in SSR environment', () => {
+    // Mock SSR environment
+    Object.defineProperty(global, 'document', {
+      value: undefined,
+      writable: true
+    });
+
+    const isActive = isDynamicThemingActive();
+
+    expect(isActive).toBe(false);
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+
+  it('returns false with null document', () => {
+    // Mock null document
+    Object.defineProperty(global, 'document', {
+      value: null,
+      writable: true
+    });
+
+    const isActive = isDynamicThemingActive();
+
+    expect(isActive).toBe(false);
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+});
+
+describe('[theming] getCurrentThemeData', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+    it('returns null when no theme is active', () => {
+    mockDocument.getElementById.mockReturnValue(null);
+
+    const themeData = getCurrentThemeData();
+
+    expect(themeData).toBeNull();
+  });
+
+  it('returns null when theme is active but data cannot be extracted', () => {
+    const existingStyle = { id: 'pace-theme-dynamic' };
+    mockDocument.getElementById.mockReturnValue(existingStyle);
+
+    const themeData = getCurrentThemeData();
+
+    expect(themeData).toBeNull();
+  });
+
+  it('returns null in SSR environment', () => {
+    // Mock SSR environment
+    Object.defineProperty(global, 'document', {
+      value: undefined,
+      writable: true
+    });
+
+    const themeData = getCurrentThemeData();
+
+    expect(themeData).toBeNull();
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+
+  it('returns null with null document', () => {
+    // Mock null document
+    Object.defineProperty(global, 'document', {
+      value: null,
+      writable: true
+    });
+
+    const themeData = getCurrentThemeData();
+
+    expect(themeData).toBeNull();
+
+    // Restore document
+    Object.defineProperty(global, 'document', {
+      value: mockDocument,
+      writable: true
+    });
+  });
+});
+
+describe('[theming] Type Definitions', () => {
+  it('defines ColorShade interface correctly', () => {
+    const colorShade: ColorShade = {
+      L: 0.5,
+      C: 0.2,
+      H: 0
+    };
+
+    expect(colorShade).toHaveProperty('L');
+    expect(colorShade).toHaveProperty('C');
+    expect(colorShade).toHaveProperty('H');
+    expect(typeof colorShade.L).toBe('number');
+    expect(typeof colorShade.C).toBe('number');
+    expect(typeof colorShade.H).toBe('number');
+  });
+
+  it('defines ColorPalette interface correctly', () => {
+    const colorPalette: ColorPalette = {
+      '50': { L: 0.95, C: 0.02, H: 0 },
+      '500': { L: 0.5, C: 0.2, H: 0 }
+    };
+
+    expect(colorPalette).toHaveProperty('50');
+    expect(colorPalette).toHaveProperty('500');
+    expect(colorPalette['50']).toHaveProperty('L');
+    expect(colorPalette['500']).toHaveProperty('C');
+  });
+
+  it('defines PaletteData interface correctly', () => {
+    const paletteData: PaletteData = {
+      main: { '500': { L: 0.5, C: 0.2, H: 0 } },
+      sec: { '500': { L: 0.5, C: 0.2, H: 120 } },
+      acc: { '500': { L: 0.5, C: 0.2, H: 240 } }
+    };
+
+    expect(paletteData).toHaveProperty('main');
+    expect(paletteData).toHaveProperty('sec');
+    expect(paletteData).toHaveProperty('acc');
+    expect(typeof paletteData.main).toBe('object');
+    expect(typeof paletteData.sec).toBe('object');
+    expect(typeof paletteData.acc).toBe('object');
+  });
+});
+
+describe('[theming] Integration Tests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockDocument.getElementById.mockReturnValue(null);
+  });
+
+    it('applies and clears palette correctly', () => {
+    const mockStyle = {
+      id: '',
+      textContent: ''
+    };
+    mockDocument.createElement.mockReturnValue(mockStyle);
+
+    const palette: PaletteData = {
+      main: { '500': { L: 0.5, C: 0.2, H: 0 } },
+      sec: { '500': { L: 0.5, C: 0.2, H: 120 } },
+      acc: { '500': { L: 0.5, C: 0.2, H: 240 } }
+    };
+
+    // Apply palette
+    applyPalette(palette);
+    expect(mockDocument.createElement).toHaveBeenCalledWith('style');
+    expect(mockDocument.head.appendChild).toHaveBeenCalled();
+
+    // Check if theming is active
+    const existingStyle = { id: 'pace-theme-dynamic', remove: vi.fn() };
+    mockDocument.getElementById.mockReturnValue(existingStyle);
+    expect(isDynamicThemingActive()).toBe(true);
+
+    // Clear palette
+    clearPalette();
+    expect(mockDocument.getElementById).toHaveBeenCalledWith('pace-theme-dynamic');
+    expect(existingStyle.remove).toHaveBeenCalled();
+  });
+
+  it('handles complete palette with all shades', () => {
+    const palette: PaletteData = {
+      main: {
+        raw: { L: 0.5, C: 0.2, H: 0 },
+        50: { L: 0.95, C: 0.02, H: 0 },
+        100: { L: 0.9, C: 0.04, H: 0 },
+        200: { L: 0.8, C: 0.08, H: 0 },
+        300: { L: 0.7, C: 0.12, H: 0 },
+        400: { L: 0.6, C: 0.16, H: 0 },
+        500: { L: 0.5, C: 0.2, H: 0 },
+        600: { L: 0.4, C: 0.16, H: 0 },
+        700: { L: 0.3, C: 0.12, H: 0 },
+        800: { L: 0.2, C: 0.08, H: 0 },
+        900: { L: 0.1, C: 0.04, H: 0 },
+        950: { L: 0.05, C: 0.02, H: 0 }
+      },
+      sec: { '500': { L: 0.5, C: 0.2, H: 120 } },
+      acc: { '500': { L: 0.5, C: 0.2, H: 240 } }
+    };
+
+    const mockStyle = {
+      id: '',
+      textContent: ''
+    };
+    mockDocument.createElement.mockReturnValue(mockStyle);
+
+    applyPalette(palette);
+
+    expect(mockStyle.textContent).toContain('--color-main-raw: oklch(0.5 0.2 0)');
+    expect(mockStyle.textContent).toContain('--color-main-50: oklch(0.95 0.02 0)');
+    expect(mockStyle.textContent).toContain('--color-main-500: oklch(0.5 0.2 0)');
+    expect(mockStyle.textContent).toContain('--color-main-950: oklch(0.05 0.02 0)');
+  });
+});