@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/services/interfaces/IInactivityService.test.ts

@@ -0,0 +1,183 @@
+/**
+ * @file IInactivityService Interface Contract Tests
+ * @package @jmruthers/pace-core
+ * @module Services/Interfaces
+ * @since 0.1.0
+ *
+ * Contract tests verifying that InactivityService implements all IInactivityService methods
+ * and that method signatures match the interface contract.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { InactivityService } from '../InactivityService';
+import type { IInactivityService } from './IInactivityService';
+import type { SupabaseClient, User, Session } from '@supabase/supabase-js';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+// Mock Supabase client
+const createMockSupabaseClient = (): SupabaseClient => ({
+  auth: {
+    getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+  },
+} as any);
+
+describe('IInactivityService Contract', () => {
+  let mockSupabaseClient: SupabaseClient;
+  let mockUser: User;
+  let mockSession: Session;
+  let mockOnIdleLogout: ReturnType<typeof vi.fn>;
+  let inactivityService: InactivityService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSupabaseClient = createMockSupabaseClient();
+    mockUser = { id: 'user-123', email: 'test@example.com' } as User;
+    mockSession = { access_token: 'token', user: mockUser } as Session;
+    mockOnIdleLogout = vi.fn();
+    inactivityService = new InactivityService(
+      mockSupabaseClient,
+      mockUser,
+      mockSession,
+      30 * 60 * 1000, // idleTimeoutMs
+      60 * 1000, // warnBeforeMs
+      mockOnIdleLogout
+    );
+  });
+
+  describe('Interface Implementation', () => {
+    it('should implement IInactivityService interface', () => {
+      // TypeScript compile-time check: if this compiles, the interface is implemented
+      const service: IInactivityService = inactivityService;
+      expect(service).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should have all required methods from IInactivityService', () => {
+      // Inactivity state methods
+      expect(typeof inactivityService.isIdle).toBe('function');
+      expect(typeof inactivityService.getTimeRemaining).toBe('function');
+      expect(typeof inactivityService.isWarningShown).toBe('function');
+      expect(typeof inactivityService.isTracking).toBe('function');
+      expect(typeof inactivityService.getShowInactivityWarning).toBe('function');
+      expect(typeof inactivityService.getInactivityTimeRemaining).toBe('function');
+
+      // Inactivity methods
+      expect(typeof inactivityService.resetActivity).toBe('function');
+      expect(typeof inactivityService.startTracking).toBe('function');
+      expect(typeof inactivityService.stopTracking).toBe('function');
+      expect(typeof inactivityService.handleIdleLogout).toBe('function');
+      expect(typeof inactivityService.handleStaySignedIn).toBe('function');
+      expect(typeof inactivityService.handleSignOutNow).toBe('function');
+
+      // Lifecycle methods
+      expect(typeof inactivityService.initialize).toBe('function');
+      expect(typeof inactivityService.cleanup).toBe('function');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Method Signatures', () => {
+    it('should have isIdle() method returning boolean', () => {
+      const result = inactivityService.isIdle();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have getTimeRemaining() method returning number', () => {
+      const result = inactivityService.getTimeRemaining();
+      expect(typeof result).toBe('number');
+    }, TEST_TIMEOUT);
+
+    it('should have isWarningShown() method returning boolean', () => {
+      const result = inactivityService.isWarningShown();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have isTracking() method returning boolean', () => {
+      const result = inactivityService.isTracking();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have getShowInactivityWarning() method returning boolean', () => {
+      const result = inactivityService.getShowInactivityWarning();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have getInactivityTimeRemaining() method returning number', () => {
+      const result = inactivityService.getInactivityTimeRemaining();
+      expect(typeof result).toBe('number');
+    }, TEST_TIMEOUT);
+
+    it('should have resetActivity() method returning void', () => {
+      const result = inactivityService.resetActivity();
+      expect(result).toBeUndefined();
+    }, TEST_TIMEOUT);
+
+    it('should have startTracking() method returning void', () => {
+      const result = inactivityService.startTracking();
+      expect(result).toBeUndefined();
+    }, TEST_TIMEOUT);
+
+    it('should have stopTracking() method returning void', () => {
+      const result = inactivityService.stopTracking();
+      expect(result).toBeUndefined();
+    }, TEST_TIMEOUT);
+
+    it('should have handleIdleLogout() method returning Promise<void>', async () => {
+      const result = inactivityService.handleIdleLogout();
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+    }, TEST_TIMEOUT);
+
+    it('should have handleStaySignedIn() method returning void', () => {
+      const result = inactivityService.handleStaySignedIn();
+      expect(result).toBeUndefined();
+    }, TEST_TIMEOUT);
+
+    it('should have handleSignOutNow() method returning Promise<void>', async () => {
+      const result = inactivityService.handleSignOutNow();
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+    }, TEST_TIMEOUT);
+
+    it('should have initialize() method returning Promise<void>', async () => {
+      const result = inactivityService.initialize();
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+    }, TEST_TIMEOUT);
+
+    it('should have cleanup() method returning void', () => {
+      const result = inactivityService.cleanup();
+      expect(result).toBeUndefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('No Missing Methods', () => {
+    it('should not have any unexpected methods that conflict with interface', () => {
+      // This is a compile-time check - if TypeScript compiles, the contract is satisfied
+      const service: IInactivityService = inactivityService;
+      
+      // Verify all interface methods exist
+      const interfaceMethods = [
+        'isIdle',
+        'getTimeRemaining',
+        'isWarningShown',
+        'isTracking',
+        'getShowInactivityWarning',
+        'getInactivityTimeRemaining',
+        'resetActivity',
+        'startTracking',
+        'stopTracking',
+        'handleIdleLogout',
+        'handleStaySignedIn',
+        'handleSignOutNow',
+        'initialize',
+        'cleanup',
+      ];
+
+      interfaceMethods.forEach(method => {
+        expect(service).toHaveProperty(method);
+        expect(typeof (service as any)[method]).toBe('function');
+      });
+    }, TEST_TIMEOUT);
+  });
+});

package/src/services/interfaces/IOrganisationService.test.ts

@@ -0,0 +1,207 @@
+/**
+ * @file IOrganisationService Interface Contract Tests
+ * @package @jmruthers/pace-core
+ * @module Services/Interfaces
+ * @since 0.1.0
+ *
+ * Contract tests verifying that OrganisationService implements all IOrganisationService methods
+ * and that method signatures match the interface contract.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { OrganisationService } from '../OrganisationService';
+import type { IOrganisationService } from './IOrganisationService';
+import type { SupabaseClient, User, Session } from '@supabase/supabase-js';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+// Mock Supabase client
+const createMockSupabaseClient = (): SupabaseClient => ({
+  auth: {
+    getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+  },
+} as any);
+
+describe('IOrganisationService Contract', () => {
+  let mockSupabaseClient: SupabaseClient;
+  let mockUser: User;
+  let mockSession: Session;
+  let organisationService: OrganisationService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSupabaseClient = createMockSupabaseClient();
+    mockUser = { id: 'user-123', email: 'test@example.com' } as User;
+    mockSession = { access_token: 'token', user: mockUser } as Session;
+    organisationService = new OrganisationService(mockSupabaseClient, mockUser, mockSession);
+  });
+
+  describe('Interface Implementation', () => {
+    it('should implement IOrganisationService interface', () => {
+      // TypeScript compile-time check: if this compiles, the interface is implemented
+      const service: IOrganisationService = organisationService;
+      expect(service).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should have all required methods from IOrganisationService', () => {
+      // Organisation state methods
+      expect(typeof organisationService.getSelectedOrganisation).toBe('function');
+      expect(typeof organisationService.getOrganisations).toBe('function');
+      expect(typeof organisationService.getUserMemberships).toBe('function');
+      expect(typeof organisationService.isLoading).toBe('function');
+      expect(typeof organisationService.getError).toBe('function');
+      expect(typeof organisationService.hasValidOrganisationContext).toBe('function');
+      expect(typeof organisationService.isContextReady).toBe('function');
+
+      // Organisation methods
+      expect(typeof organisationService.switchOrganisation).toBe('function');
+      expect(typeof organisationService.getUserRole).toBe('function');
+      expect(typeof organisationService.validateOrganisationAccess).toBe('function');
+      expect(typeof organisationService.refreshOrganisations).toBe('function');
+      expect(typeof organisationService.ensureOrganisationContext).toBe('function');
+      expect(typeof organisationService.isOrganisationSecure).toBe('function');
+      expect(typeof organisationService.getPrimaryOrganisation).toBe('function');
+      expect(typeof organisationService.buildOrganisationHierarchy).toBe('function');
+
+      // Lifecycle methods
+      expect(typeof organisationService.initialize).toBe('function');
+      expect(typeof organisationService.cleanup).toBe('function');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Method Signatures', () => {
+    it('should have getSelectedOrganisation() method returning Organisation | null', () => {
+      const result = organisationService.getSelectedOrganisation();
+      expect(result === null || typeof result === 'object').toBe(true);
+    }, TEST_TIMEOUT);
+
+    it('should have getOrganisations() method returning Organisation[]', () => {
+      const result = organisationService.getOrganisations();
+      expect(Array.isArray(result)).toBe(true);
+    }, TEST_TIMEOUT);
+
+    it('should have getUserMemberships() method returning OrganisationMembership[]', () => {
+      const result = organisationService.getUserMemberships();
+      expect(Array.isArray(result)).toBe(true);
+    }, TEST_TIMEOUT);
+
+    it('should have isLoading() method returning boolean', () => {
+      const result = organisationService.isLoading();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have getError() method returning Error | null', () => {
+      const result = organisationService.getError();
+      expect(result === null || result instanceof Error).toBe(true);
+    }, TEST_TIMEOUT);
+
+    it('should have hasValidOrganisationContext() method returning boolean', () => {
+      const result = organisationService.hasValidOrganisationContext();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have isContextReady() method returning boolean', () => {
+      const result = organisationService.isContextReady();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have switchOrganisation() method accepting string, returning Promise<void>', async () => {
+      const result = organisationService.switchOrganisation('org-123');
+      expect(result).toBeInstanceOf(Promise);
+      // May throw if user doesn't have access, which is expected behavior
+      try {
+        await result;
+      } catch (error) {
+        // Expected if user doesn't have access to the organisation
+        expect(error).toBeInstanceOf(Error);
+      }
+    }, TEST_TIMEOUT);
+
+    it('should have getUserRole() method accepting optional string, returning string', () => {
+      const result = organisationService.getUserRole('org-123');
+      expect(typeof result).toBe('string');
+    }, TEST_TIMEOUT);
+
+    it('should have validateOrganisationAccess() method accepting string, returning boolean', () => {
+      const result = organisationService.validateOrganisationAccess('org-123');
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have refreshOrganisations() method returning Promise<void>', async () => {
+      const result = organisationService.refreshOrganisations();
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+    }, TEST_TIMEOUT);
+
+    it('should have ensureOrganisationContext() method returning Organisation', () => {
+      // This may throw if no organisation is available, which is expected
+      try {
+        const result = organisationService.ensureOrganisationContext();
+        expect(typeof result).toBe('object');
+      } catch (error) {
+        // Expected if no organisation context is available
+        expect(error).toBeDefined();
+      }
+    }, TEST_TIMEOUT);
+
+    it('should have isOrganisationSecure() method returning boolean', () => {
+      const result = organisationService.isOrganisationSecure();
+      expect(typeof result).toBe('boolean');
+    }, TEST_TIMEOUT);
+
+    it('should have getPrimaryOrganisation() method returning Organisation | null', () => {
+      const result = organisationService.getPrimaryOrganisation();
+      expect(result === null || typeof result === 'object').toBe(true);
+    }, TEST_TIMEOUT);
+
+    it('should have buildOrganisationHierarchy() method accepting Organisation[], returning OrganisationHierarchy[]', () => {
+      const result = organisationService.buildOrganisationHierarchy([]);
+      expect(Array.isArray(result)).toBe(true);
+    }, TEST_TIMEOUT);
+
+    it('should have initialize() method returning Promise<void>', async () => {
+      const result = organisationService.initialize();
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+    }, TEST_TIMEOUT);
+
+    it('should have cleanup() method returning void', () => {
+      const result = organisationService.cleanup();
+      expect(result).toBeUndefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('No Missing Methods', () => {
+    it('should not have any unexpected methods that conflict with interface', () => {
+      // This is a compile-time check - if TypeScript compiles, the contract is satisfied
+      const service: IOrganisationService = organisationService;
+      
+      // Verify all interface methods exist
+      const interfaceMethods = [
+        'getSelectedOrganisation',
+        'getOrganisations',
+        'getUserMemberships',
+        'isLoading',
+        'getError',
+        'hasValidOrganisationContext',
+        'isContextReady',
+        'switchOrganisation',
+        'getUserRole',
+        'validateOrganisationAccess',
+        'refreshOrganisations',
+        'ensureOrganisationContext',
+        'isOrganisationSecure',
+        'getPrimaryOrganisation',
+        'buildOrganisationHierarchy',
+        'initialize',
+        'cleanup',
+      ];
+
+      interfaceMethods.forEach(method => {
+        expect(service).toHaveProperty(method);
+        expect(typeof (service as any)[method]).toBe('function');
+      });
+    }, TEST_TIMEOUT);
+  });
+});

package/src/services/interfaces/IOrganisationService.ts

@@ -11,7 +11,6 @@
 import type {
   Organisation,
   OrganisationMembership,
-  OrganisationSecurityError,
   OrganisationHierarchy
 } from '../../types/organisation';
 

package/src/styles/core.css

@@ -7,13 +7,27 @@
   --font-serif: "Open Sans", sans-serif;
   --font-mono: "Reddit Mono", monospace;
   --font-heading: "Georama", sans-serif;
-  --shadow-badge-soft: 0 0 0 0.1rem var(--color-main-600),  0 0 0 5rem var(--color-main-600) inset,  0 0 0.25rem 0.25rem var(--color-main-600);
-  --shadow-badge-soft-xl: 0 0 0 0.1rem var(--color-main-600),  0 0 0 5rem var(--color-main-600) inset,  0 0 0.25rem 0.75rem var(--color-main-600);
+  --shadow-badge-soft: 0 0 0 0.1rem var(--color-main-600), 0 0 0 5rem var(--color-main-600) inset, 0 0 0.25rem 0.25rem var(--color-main-600);
+  --shadow-badge-soft-xl: 0 0 0 0.1rem var(--color-main-600), 0 0 0 5rem var(--color-main-600) inset, 0 0 0.25rem 0.75rem var(--color-main-600);
+  /* Main content area max width: min(app-width, 100%). Consuming apps may set --app-width in app.css. */
+  --size-app-content-max: min(var(--app-width, 100%), 100%);
+  /* Layout z-index: header above content */
+  --z-header: 40;
+  /* Header horizontal padding: centers content when viewport wider than --app-width. Used by PublicPageHeader. */
+  --layout-header-padding-x: max(0rem, calc((100vw - var(--app-width, 100%)) / 2 - 0.5rem));
 }
 
 @layer base {
 
-  /*base resets */
+  /* Print header/footer variables on :root only so runtime can override on html and descendants inherit */
+  :root {
+    --print-title: "Print Title";
+    --print-event-name: "Event Name";
+    --print-app-name: "PACE";
+    --print-date-time: "Print Date Time";
+  }
+
+  /* Base resets */
   * {
     font-family: 'Open Sans';
     border-color: var(--color-border);
@@ -73,6 +87,7 @@
   h5,
   h6 {
     margin-bottom: 0.25lh;
+    text-wrap: balance;
   }
 
   h1,
@@ -179,6 +194,7 @@
     margin: 0.25lh 0;
     padding-left: 1.5rem;
   }
+
   ul {
     list-style-type: disc;
   }
@@ -207,17 +223,13 @@
     background-color: oklch(from var(--color-main-700) l c h / 0.5);
   }
 
-  progress::indeterminate {
-    
-    background: var(--color-acc-600);
-    /*
-    background: linear-gradient(to right, var(--color-acc-700) 10%, var(--color-sec-200) 30%, var(--color-main-500) 70%, var(--color-acc-200) 90%); */
-  }
-  
+
+
   .appGradient {
     background: linear-gradient(145deg, var(--color-main-100) 10%, var(--color-main-200) 30%, var(--color-main-200) 70%, var(--color-main-300) 90%);
     background-attachment: fixed;
   }
+
 }
 
 @theme inline {
@@ -244,13 +256,111 @@
 }
 
 @layer components {
+
   /* Custom component styles go here */
+  progress {
+    background: var(--color-sec-200);
+  }
+
+  progress:not(:indeterminate)::-webkit-progress-value,
+  progress:not(:indeterminate)::-moz-progress-bar {
+    background: var(--color-main-700);
+  }
+
+  progress.progress-error:not(:indeterminate)::-webkit-progress-value,
+  progress.progress-error:not(:indeterminate)::-moz-progress-bar {
+    background: var(--color-acc-500);
+  }
+
+  progress:indeterminate {
+    background: linear-gradient(to right, var(--color-sec-200) 10%, var(--color-main-500) 30%, var(--color-main-500) 70%, var(--color-sec-200) 90%);
+    accent-color: transparent;
+    /* Prevent browser default accent color */
+  }
+
+  progress:indeterminate::-webkit-progress-bar {
+    background: linear-gradient(to right, var(--color-sec-200) 10%, var(--color-main-500) 30%, var(--color-main-500) 70%, var(--color-sec-200) 90%);
+  }
+
+  /* Dialog body: HTML content paragraph (replaces prose prose-sm max-w-none) */
+  .dialog-body-html-content {
+    font-size: 0.875rem;
+    line-height: 1.6;
+    max-width: none;
+  }
+
+  /* Dialog body: fallback message when HTML content is not processed */
+  .dialog-body-fallback {
+    color: var(--color-acc-500);
+    margin-bottom: 0.5rem;
+  }
+
+  /* Dialog header: layout, alignment, spacing (avoids typography utilities in component) */
+  .dialog-header {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+    margin-bottom: 1rem;
+    text-align: center;
+  }
+  @media (min-width: 640px) {
+    .dialog-header {
+      text-align: left;
+    }
+  }
+
+  /* Dialog footer: layout and spacing (avoids typography utilities in component) */
+  .dialog-footer {
+    margin-top: 1rem;
+    display: flex;
+    flex-direction: column-reverse;
+    gap: 0.5rem;
+  }
+  @media (min-width: 640px) {
+    .dialog-footer {
+      flex-direction: row;
+      justify-content: flex-end;
+    }
+  }
+
+  /* Card size: typography in core.css (avoids typography utilities in component) */
+  .card--sm {
+    font-size: 0.875rem;
+  }
+  .card--lg {
+    font-size: 1.125rem;
+  }
+
 }
 
+
+
 @layer utilities {
   /* Custom utility styles go here */
-  
-  
+
+  /* Main content area max width: uses --size-app-content-max from @theme (min(app-width, 100%)) */
+  .max-w-app-content-max {
+    max-width: var(--size-app-content-max);
+  }
+
+  /* Header horizontal padding: uses --layout-header-padding-x from @theme (centers when viewport > app-width) */
+  .px-app-header-inset {
+    padding-left: var(--layout-header-padding-x);
+    padding-right: var(--layout-header-padding-x);
+  }
+
+  /* Header z-index: uses --z-header from @theme */
+  .z-header {
+    z-index: var(--z-header);
+  }
+
+  /* Print page orientation utilities */
+  @media print {
+    .print-page-landscape {
+      page: landscape;
+    }
+  }
+
   /* Hide spinner arrows on all number inputs (modern UX convention) */
   input[type="number"]::-webkit-inner-spin-button,
   input[type="number"]::-webkit-outer-spin-button {
@@ -260,5 +370,127 @@
 
   input[type="number"] {
     -moz-appearance: textfield;
+    appearance: textfield;
+  }
+}
+
+@media print {
+  @page {
+    size: A4 portrait;
+    margin: 20mm 15mm 15mm;
+    border: 1px solid var(--color-sec-600);
+
+    @top-left {
+      content: var(--print-title);
+      font-family: 'Georama';
+      font-size: 18pt;
+      line-height: 20pt;
+      font-weight: 700;
+      color: var(--color-main-600);
+      vertical-align: bottom;
+      padding-bottom: 0pt;
+    }
+
+    @top-right {
+      content: var(--print-event-name);
+      font-family: 'Georama';
+      font-size: 14pt;
+      line-height: 16pt;
+      font-weight: 600;
+      color: var(--color-main-600);
+      vertical-align: bottom;
+      padding-bottom: 0pt;
+    }
+
+    @bottom-left {
+      content: "Powered by " var(--print-app-name);
+      font-size: 8pt;
+      display: table-cell;
+      vertical-align: top;
+    }
+
+    @bottom-center {
+      content: "Page " counter(page) " of " counter(pages);
+      font-size: 8pt;
+      display: table-cell;
+      vertical-align: top;
+    }
+
+    @bottom-right {
+      content: var(--print-date-time);
+      font-size: 8pt;
+      display: table-cell;
+      vertical-align: top;
+    }
+
+  }
+
+  @page landscape {
+    size: A4 landscape;
+    margin: 20mm 15mm 15mm;
+  }
+
+  h1 {
+    font-size: 25pt;
+  }
+
+  h2 {
+    font-size: 20pt;
+  }
+
+  h3 {
+    font-size: 18pt;
+  }
+
+  h4 {
+    font-size: 15pt;
+    letter-spacing: -0.5pt;
+  }
+
+  h5 {
+    font-size: 13pt;
+    letter-spacing: -0.25pt;
+  }
+
+  h6 {
+    font-size: 10pt;
   }
+
+  p {
+    font-size: 10pt;
+  }
+
+  pre,
+  code {
+    font-size: 9pt;
+    padding: 2pt 4pt;
+    border-radius: 2.5pt;
+  }
+
+  blockquote {
+    padding: 2pt 4pt;
+    margin: 1.15pt 0;
+  }
+
+  small {
+    font-size: 9pt;
+  }
+
+  .appGradient {
+    background: none;
+  }
+
+  main>article:not(main [class*="grid"] > article),
+  main>section>article:not(main [class*="grid"] > article) {
+    border: none;
+
+    >header,
+    >main,
+    >footer {
+      padding-left: 0;
+      padding-right: 0;
+    }
+  }
+
+
 }