@jmruthers/pace-core 0.2.4

package/dist/types-CInEi-ng.d.ts

@@ -0,0 +1,316 @@
+import React__default from 'react';
+import { ColumnDef, SortingState, ColumnFiltersState, GroupingState } from '@tanstack/react-table';
+
+/**
+ * @file DataTable Type Definitions
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Types
+ * @since 0.2.0
+ */
+
+/**
+ * Generic data record type - all DataTable data must extend this
+ */
+type DataRecord = Record<string, any>;
+/**
+ * Row identifier function type
+ */
+type GetRowId<TData extends DataRecord> = (row: TData, index: number) => string;
+/**
+ * Hierarchical configuration for DataTable
+ */
+interface HierarchicalConfig {
+    /** Enable hierarchical functionality */
+    enabled: boolean;
+    /** Default expanded state - true = all expanded, false = all collapsed, array = specific IDs */
+    defaultExpanded?: boolean | string[];
+    /** Callback when expanded state changes */
+    onExpandedChange?: (expandedIds: string[]) => void;
+    /** Custom expand/collapse button component */
+    expandButton?: React__default.ComponentType<ExpandButtonProps>;
+    /** Visual indentation for child rows (in pixels) */
+    indentSize?: number;
+    /** Custom styling for parent rows */
+    parentRowClassName?: string;
+    /** Custom styling for child rows */
+    childRowClassName?: string;
+}
+/**
+ * Props for the expand/collapse button component
+ */
+interface ExpandButtonProps {
+    /** Row ID */
+    rowId: string;
+    /** Whether the row is currently expanded */
+    isExpanded: boolean;
+    /** Whether this row has children */
+    hasChildren: boolean;
+    /** Click handler */
+    onClick: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * Pagination mode determines how data is handled
+ */
+type PaginationMode = 'client' | 'server' | 'hybrid';
+/**
+ * Performance configuration for large datasets
+ */
+interface PerformanceConfig {
+    /** Enable virtual scrolling */
+    virtualScrolling?: boolean;
+    /** Virtual scrolling overscan count */
+    overscan?: number;
+    /** Enable memoization of cell renderers */
+    memoizeCells?: boolean;
+    /** Enable debounced search */
+    debounceSearch?: number;
+    /** Enable data chunking for memory management */
+    enableChunking?: boolean;
+    /** Chunk size for data processing */
+    chunkSize?: number;
+    /** Enable Web Workers for heavy operations */
+    enableWebWorkers?: boolean;
+    /** Threshold for switching to server-side mode */
+    serverSideThreshold?: number;
+}
+/**
+ * Server-side data fetching configuration
+ */
+interface ServerSideConfig<TData extends DataRecord> {
+    /** Function to fetch data from server */
+    fetchData: (params: ServerSideParams) => Promise<ServerSideResponse<TData>>;
+    /** Enable server-side sorting */
+    enableServerSorting?: boolean;
+    /** Enable server-side filtering */
+    enableServerFiltering?: boolean;
+    /** Enable server-side search */
+    enableServerSearch?: boolean;
+    /** Enable server-side pagination */
+    enableServerPagination?: boolean;
+    /** Debounce delay for server requests */
+    debounceMs?: number;
+    /** Cache duration for server responses */
+    cacheMs?: number;
+}
+/**
+ * Parameters sent to server for data fetching
+ */
+interface ServerSideParams {
+    /** Current page index */
+    pageIndex: number;
+    /** Page size */
+    pageSize: number;
+    /** Sorting configuration */
+    sorting: SortingState;
+    /** Column filters */
+    columnFilters: ColumnFiltersState;
+    /** Global filter/search term */
+    globalFilter: string;
+    /** Grouping configuration */
+    grouping: GroupingState;
+}
+/**
+ * Response from server for data fetching
+ */
+interface ServerSideResponse<TData extends DataRecord> {
+    /** Array of data records */
+    data: TData[];
+    /** Total number of records (for pagination) */
+    totalCount: number;
+    /** Current page index */
+    pageIndex: number;
+    /** Page size */
+    pageSize: number;
+    /** Total number of pages */
+    pageCount: number;
+    /** Whether there are more pages */
+    hasNextPage: boolean;
+    /** Whether there are previous pages */
+    hasPreviousPage: boolean;
+}
+/**
+ * Data chunking configuration
+ */
+interface ChunkingConfig {
+    /** Size of each data chunk */
+    chunkSize: number;
+    /** Number of chunks to keep in memory */
+    maxChunksInMemory: number;
+    /** Enable progressive loading */
+    progressiveLoading?: boolean;
+}
+/**
+ * Search index configuration for performance
+ */
+interface SearchIndexConfig {
+    /** Fields to index for search */
+    indexedFields: string[];
+    /** Enable fuzzy search */
+    fuzzySearch?: boolean;
+    /** Fuzzy search threshold */
+    fuzzyThreshold?: number;
+    /** Enable search highlighting */
+    enableHighlighting?: boolean;
+}
+/**
+ * Enhanced column definition that extends TanStack's ColumnDef
+ */
+interface DataTableColumn<TData extends DataRecord = DataRecord> extends Omit<ColumnDef<TData>, 'id' | 'accessorKey'> {
+    /** Column identifier */
+    id?: string;
+    /** Accessor key for data */
+    accessorKey?: string;
+    /** Custom header label for the column */
+    header: string;
+    /** Whether this column should be searchable in global filter */
+    searchable?: boolean;
+    /** Enable sorting */
+    sortable?: boolean;
+    /** Enable column filter (inherits from ColumnDef) */
+    enableColumnFilter?: boolean;
+    /** Enable grouping (inherits from ColumnDef) */
+    enableGrouping?: boolean;
+    /** Enable hiding (inherits from ColumnDef) */
+    enableHiding?: boolean;
+    /** Aggregate configuration for this column */
+    aggregate?: AggregateConfig;
+    /** Enable virtual scrolling for this column */
+    virtualizable?: boolean;
+    /** Custom cell renderer with memoization */
+    memoizedCell?: React__default.ComponentType<any>;
+    /** Field type for editing (text, select, date, etc.) */
+    fieldType?: 'text' | 'select' | 'date' | 'number' | 'boolean';
+    /** Options for select fields */
+    fieldOptions?: Array<{
+        value: string | number;
+        label: string;
+    }>;
+    /** Filter type for column filtering (text, select, number, date) */
+    filterType?: 'text' | 'select' | 'number' | 'date';
+    /** Custom renderer for parent rows */
+    renderForParent?: (row: TData) => React__default.ReactNode;
+    /** Custom renderer for child rows */
+    renderForChild?: (row: TData) => React__default.ReactNode;
+    /** Hide this column for parent rows */
+    hideForParent?: boolean;
+    /** Hide this column for child rows */
+    hideForChild?: boolean;
+}
+/**
+ * Action definition for row-level operations
+ */
+interface DataTableAction<TData extends DataRecord> {
+    /** Display label for the action */
+    label: string;
+    /** Icon component */
+    icon?: React__default.ComponentType<{
+        className?: string;
+    }>;
+    /** Action handler */
+    onClick: (row: TData) => void;
+    /** Visual variant */
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
+    /** Whether action is disabled */
+    disabled?: (row: TData) => boolean;
+    /** Test ID for testing */
+    testId?: string;
+    /** Whether this action should only show for parent rows (hierarchical mode) */
+    showForParent?: boolean;
+    /** Whether this action should only show for child rows (hierarchical mode) */
+    showForChild?: boolean;
+    /** Icon component for parent rows (overrides icon when showForParent is true) */
+    parentIcon?: React__default.ComponentType<{
+        className?: string;
+    }>;
+    /** Icon component for child rows (overrides icon when showForChild is true) */
+    childIcon?: React__default.ComponentType<{
+        className?: string;
+    }>;
+    /** Label for parent rows (overrides label when showForParent is true) */
+    parentLabel?: string;
+    /** Label for child rows (overrides label when showForChild is true) */
+    childLabel?: string;
+}
+/**
+ * Toolbar button definition
+ */
+interface DataTableToolbarButton {
+    /** Display label */
+    label: string;
+    /** Icon component */
+    icon?: React__default.ComponentType<{
+        className?: string;
+    }>;
+    /** Click handler */
+    onClick: () => void;
+    /** Visual variant */
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
+    /** Whether button is disabled */
+    disabled?: boolean;
+    /** Test ID for testing */
+    testId?: string;
+}
+/**
+ * Aggregate configuration
+ */
+interface AggregateConfig {
+    field: string;
+    function: 'sum' | 'avg' | 'count' | 'min' | 'max';
+    label: string;
+}
+/**
+ * Empty state configuration
+ */
+interface EmptyStateConfig {
+    title?: string;
+    description?: string;
+    icon?: React__default.ComponentType<{
+        className?: string;
+    }>;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+/**
+ * Unified feature configuration for DataTable
+ * All features are disabled by default and must be explicitly enabled
+ */
+interface DataTableFeatureConfig {
+    /** Enable global search functionality */
+    search: boolean;
+    /** Enable pagination controls */
+    pagination: boolean;
+    /** Enable column sorting */
+    sorting: boolean;
+    /** Enable column filtering */
+    filtering: boolean;
+    /** Enable data import functionality */
+    import: boolean;
+    /** Enable data export functionality */
+    export: boolean;
+    /** Enable row selection for bulk operations */
+    selection: boolean;
+    /** Enable row creation */
+    creation: boolean;
+    /** Enable row editing */
+    editing: boolean;
+    /** Enable row deletion */
+    deletion: boolean;
+    /** Enable bulk deletion of selected rows */
+    deleteSelected: boolean;
+    /** Enable data grouping */
+    grouping: boolean;
+    /** Enable column visibility controls */
+    columnVisibility: boolean;
+    /** Enable column reordering */
+    columnReordering: boolean;
+    /** Enable hierarchical parent/child rows */
+    hierarchical: boolean;
+    /** Enable automatic column width adjustment based on content */
+    autoColumnSizing?: boolean;
+}
+
+export type { AggregateConfig as A, ChunkingConfig as C, DataRecord as D, EmptyStateConfig as E, GetRowId as G, HierarchicalConfig as H, PerformanceConfig as P, ServerSideConfig as S, DataTableColumn as a, DataTableFeatureConfig as b, PaginationMode as c, SearchIndexConfig as d, DataTableAction as e, DataTableToolbarButton as f, ServerSideParams as g, ServerSideResponse as h };

package/dist/types.d.ts

@@ -0,0 +1,196 @@
+import { U as User, S as Session, A as AuthError, a as UserPermissions, P as PermissionError, b as PermissionString, c as AccessLevel, d as AuthErrorCode } from './unified-CM7T0aTK.js';
+export { D as DataRecord, t as DataTableAction, u as DataTableColumn, r as Event, s as EventContextType, E as EventTheme, q as PermissionContext, e as PermissionErrorCode, p as PermissionMap, R as RequestId, g as SessionToken, T as ThemeColors, f as UserId, j as createPermissionString, k as createRequestId, i as createSessionToken, h as createUserId, n as isPermissionString, o as isRequestId, m as isSessionToken, l as isUserId } from './unified-CM7T0aTK.js';
+import { SupabaseClient } from '@supabase/supabase-js';
+export { D as Database } from './database-C3Szpi5J.js';
+export { C as ChangePasswordFormValues, t as ContactFormData, F as FormData, m as LoginFormData, L as LoginFormValues, P as PasswordResetFormValues, q as ProfileFormData, o as RegistrationFormData, R as RegistrationFormValues, S as SecureLoginFormValues, k as SecurePasswordResetFormValues, j as SecureRegistrationFormValues, U as UserProfileFormValues, V as ValidationError, a as ValidationResult, g as changePasswordSchema, w as combineSchemas, i as contactFormSchema, d as dateSchema, e as emailSchema, l as loginSchema, n as nameSchema, f as passwordResetSchema, b as passwordSchema, p as phoneSchema, v as pickSchema, r as registrationSchema, c as secureLoginSchema, s as securePasswordSchema, u as urlSchema, h as userProfileSchema } from './validation-PM_iOaTI.js';
+import 'zod';
+
+/**
+ * @file Supabase Integration Types
+ *
+ * TypeScript interfaces for Supabase client operations with standard types.
+ */
+
+/**
+ * Standard Supabase client - no custom wrapper needed
+ */
+type TypedSupabaseClient<Database = unknown> = SupabaseClient<Database>;
+/**
+ * Standard query result wrapper
+ */
+interface QueryResult<T = unknown> {
+    data: T | null;
+    error: unknown | null;
+    count?: number | null;
+    status: number;
+    statusText: string;
+}
+/**
+ * Authentication operations interface
+ */
+interface AuthOperations {
+    signIn(email: string, password: string): Promise<{
+        data: {
+            user: User;
+            session: Session;
+        } | null;
+        error: AuthError | null;
+    }>;
+    signUp(email: string, password: string): Promise<{
+        data: {
+            user: User;
+        } | null;
+        error: AuthError | null;
+    }>;
+    signOut(): Promise<{
+        error: AuthError | null;
+    }>;
+    getSession(): Promise<{
+        data: {
+            session: Session;
+        } | null;
+        error: AuthError | null;
+    }>;
+    refreshSession(): Promise<{
+        data: {
+            session: Session;
+        } | null;
+        error: AuthError | null;
+    }>;
+    resetPassword(email: string): Promise<{
+        data: unknown;
+        error: AuthError | null;
+    }>;
+    updateUser(attributes: Partial<User>): Promise<{
+        data: {
+            user: User;
+        } | null;
+        error: AuthError | null;
+    }>;
+}
+/**
+ * Permission operations interface
+ */
+interface PermissionOperations {
+    getUserPermissions(userId: string, eventId: string, appName: string): Promise<{
+        data: UserPermissions | null;
+        error: PermissionError | null;
+    }>;
+    checkPermission(userId: string, permission: PermissionString, eventId: string, appName: string): Promise<{
+        data: {
+            granted: boolean;
+        } | null;
+        error: PermissionError | null;
+    }>;
+    grantPermission(userId: string, permission: PermissionString, eventId: string, appName: string): Promise<{
+        data: null;
+        error: PermissionError | null;
+    }>;
+    revokePermission(userId: string, permission: PermissionString, eventId: string, appName: string): Promise<{
+        data: null;
+        error: PermissionError | null;
+    }>;
+    setUserAccessLevel(userId: string, accessLevel: AccessLevel, eventId: string, appName: string): Promise<{
+        data: null;
+        error: PermissionError | null;
+    }>;
+}
+/**
+ * Supabase table names for type safety
+ */
+type TableName = 'users' | 'rbac_global_roles' | 'rbac_organisation_roles' | 'rbac_event_app_roles' | 'rbac_page_permissions' | 'rbac_user_sessions' | 'rbac_user_profiles' | 'rbac_user_login_history' | 'event' | 'organisations' | 'rbac_apps';
+/**
+ * Supabase RPC function names
+ */
+type RPCFunction = 'get_rbac_permissions' | 'get_user_app_permissions' | 'get_user_current_roles' | 'get_user_event_access' | 'get_user_events' | 'get_user_organisations' | 'get_user_organisation_ids' | 'get_user_effective_organisations' | 'get_app_config' | 'get_organisation_apps' | 'get_organisation_hierarchy' | 'grant_user_role' | 'revoke_user_role' | 'grant_direct_app_access' | 'revoke_direct_app_access' | 'check_page_permission' | 'has_organisation_permission' | 'has_organisation_role' | 'user_has_role_in_org' | 'user_has_min_role_in_org' | 'can_access_event' | 'can_access_organisation' | 'is_super_admin' | 'is_admin' | 'track_user_session' | 'record_user_login' | 'log_organisation_access' | 'log_medi_access' | 'get_pace_user_events';
+/**
+ * Helper type for Supabase filter operations
+ */
+interface SupabaseFilter {
+    column: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'in' | 'is';
+    value: unknown;
+}
+/**
+ * Helper type for Supabase order operations
+ */
+interface SupabaseOrder {
+    column: string;
+    ascending?: boolean;
+    nullsFirst?: boolean;
+}
+
+/**
+ * @file Type Guards
+ */
+
+declare function isAuthErrorCode(code: string): code is AuthErrorCode;
+declare function isUser(obj: unknown): obj is User;
+declare function isSession(obj: unknown): obj is Session;
+
+/**
+ * @file Security-related Types
+ * @description Type definitions for security features
+ */
+interface SecurityConfig {
+    /** Enable device fingerprinting */
+    deviceFingerprinting: boolean;
+    /** Enable CSRF protection */
+    csrfProtection: boolean;
+    /** Password validation level */
+    passwordValidation: 'basic' | 'strict';
+    /** Session timeout in milliseconds */
+    sessionTimeout: number;
+    /** Maximum login attempts before lockout */
+    maxLoginAttempts: number;
+    /** Rate limit window in milliseconds */
+    rateLimitWindow: number;
+}
+interface SecurityMetrics {
+    /** Number of failed authentication attempts */
+    failedAttempts: number;
+    /** Last login timestamp */
+    lastLogin: number;
+    /** Device trust score (0-100) */
+    deviceTrustScore: number;
+    /** Session risk level */
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+}
+interface SecurityEvent {
+    /** Event type */
+    type: 'login_attempt' | 'login_success' | 'login_failure' | 'permission_denied' | 'suspicious_activity';
+    /** User ID (if known) */
+    userId?: string;
+    /** Session ID */
+    sessionId?: string;
+    /** Event timestamp */
+    timestamp: number;
+    /** Event details */
+    details: Record<string, unknown>;
+    /** Risk level */
+    riskLevel: SecurityMetrics['riskLevel'];
+    /** IP address (hashed for privacy) */
+    ipHash?: string;
+    /** User agent hash */
+    userAgentHash?: string;
+}
+interface RateLimitConfig {
+    /** Maximum attempts allowed */
+    maxAttempts: number;
+    /** Time window in milliseconds */
+    windowMs: number;
+    /** Penalty multiplier for repeated violations */
+    penaltyMultiplier: number;
+}
+interface SecurityAuditLog {
+    /** Unique audit entry ID */
+    id: string;
+    /** Event that was audited */
+    event: SecurityEvent;
+    /** Action taken (if any) */
+    action?: 'blocked' | 'warned' | 'logged' | 'escalated';
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+
+export { AccessLevel, AuthError, AuthErrorCode, type AuthOperations, PermissionError, type PermissionOperations, PermissionString, type QueryResult, type RPCFunction, type RateLimitConfig, type SecurityAuditLog, type SecurityConfig, type SecurityEvent, type SecurityMetrics, Session, type SupabaseFilter, type SupabaseOrder, type TableName, type TypedSupabaseClient, User, UserPermissions, isAuthErrorCode, isSession, isUser };

package/dist/types.js

@@ -0,0 +1,83 @@
+import {
+  changePasswordSchema,
+  combineSchemas,
+  contactFormSchema,
+  dateSchema,
+  emailSchema,
+  loginSchema,
+  nameSchema,
+  passwordResetSchema,
+  passwordSchema,
+  phoneSchema,
+  pickSchema,
+  registrationSchema,
+  secureLoginSchema,
+  securePasswordSchema,
+  urlSchema,
+  userProfileSchema
+} from "./chunk-24MKLB7U.js";
+import {
+  AccessLevel,
+  AuthErrorCode,
+  PermissionErrorCode,
+  createPermissionString,
+  createRequestId,
+  createSessionToken,
+  createUserId,
+  init_unified,
+  isPermissionString,
+  isRequestId,
+  isSessionToken,
+  isUserId
+} from "./chunk-YDJW5XTN.js";
+import "./chunk-PLDDJCW6.js";
+
+// src/types/index.ts
+init_unified();
+
+// src/types/guards.ts
+init_unified();
+function isAuthErrorCode(code) {
+  return Object.values(AuthErrorCode).includes(code);
+}
+function isUser(obj) {
+  const candidate = obj;
+  return candidate != null && typeof candidate === "object" && typeof candidate.id === "string" && typeof candidate.created_at === "string";
+}
+function isSession(obj) {
+  const candidate = obj;
+  return candidate != null && typeof candidate === "object" && typeof candidate.access_token === "string" && typeof candidate.user === "object";
+}
+export {
+  AccessLevel,
+  AuthErrorCode,
+  PermissionErrorCode,
+  changePasswordSchema,
+  combineSchemas,
+  contactFormSchema,
+  createPermissionString,
+  createRequestId,
+  createSessionToken,
+  createUserId,
+  dateSchema,
+  emailSchema,
+  isAuthErrorCode,
+  isPermissionString,
+  isRequestId,
+  isSession,
+  isSessionToken,
+  isUser,
+  isUserId,
+  loginSchema,
+  nameSchema,
+  passwordResetSchema,
+  passwordSchema,
+  phoneSchema,
+  pickSchema,
+  registrationSchema,
+  secureLoginSchema,
+  securePasswordSchema,
+  urlSchema,
+  userProfileSchema
+};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/index.ts","../src/types/guards.ts"],"sourcesContent":["/**\n * @file Types Module Exports\n * @package @jmruthers/pace-core\n * @module Types\n * @since 0.1.0\n * \n * Complete collection of type definitions for the PACE Core library.\n * Use this import path when you need access to types not included in the main export.\n * \n * @example\n * // Specialized type imports\n * import { User, Event, AccessLevel } from '@jmruthers/pace-core/types';\n * \n * // For common types, prefer the main export:\n * import { ButtonProps, CardProps } from '@jmruthers/pace-core';\n */\n\n// Core type exports\nexport * from './unified';\nexport * from './supabase';\nexport * from './database';\nexport * from './guards';\nexport * from './validation';\nexport * from './theme';\nexport * from './security';\n","\n/**\n * @file Type Guards\n */\n\nimport { AuthErrorCode, User, Session } from './unified';\n\nexport function isAuthErrorCode(code: string): code is AuthErrorCode {\n  return Object.values(AuthErrorCode).includes(code as AuthErrorCode);\n}\n\nexport function isUser(obj: unknown): obj is User {\n  const candidate = obj as Partial<User> | null | undefined;\n  return (\n    candidate != null &&\n    typeof candidate === 'object' &&\n    typeof candidate.id === 'string' &&\n    typeof candidate.created_at === 'string'\n  );\n}\n\nexport function isSession(obj: unknown): obj is Session {\n  const candidate = obj as Partial<Session> | null | undefined;\n  return (\n    candidate != null &&\n    typeof candidate === 'object' &&\n    typeof candidate.access_token === 'string' &&\n    typeof candidate.user === 'object'\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA;;;ACbA;AAEO,SAAS,gBAAgB,MAAqC;AACnE,SAAO,OAAO,OAAO,aAAa,EAAE,SAAS,IAAqB;AACpE;AAEO,SAAS,OAAO,KAA2B;AAChD,QAAM,YAAY;AAClB,SACE,aAAa,QACb,OAAO,cAAc,YACrB,OAAO,UAAU,OAAO,YACxB,OAAO,UAAU,eAAe;AAEpC;AAEO,SAAS,UAAU,KAA8B;AACtD,QAAM,YAAY;AAClB,SACE,aAAa,QACb,OAAO,cAAc,YACrB,OAAO,UAAU,iBAAiB,YAClC,OAAO,UAAU,SAAS;AAE9B;","names":[]}