@mui-toolpad-extended-tuni/core 3.0.0

package/README.md

@@ -0,0 +1,99 @@
+# @mui-toolpad-extended-tuni/core
+
+Core shared package for MUI Toolpad Extended TUNI microservices.
+
+This package contains shared dependencies used by all microservices in the MUI Toolpad Extended TUNI ecosystem.
+
+## Installation
+
+```bash
+npm install @mui-toolpad-extended-tuni/core
+```
+
+## Peer Dependencies
+
+This package requires the following peer dependencies:
+
+- `@emotion/react`: ^11.0.0
+- `@emotion/styled`: ^11.0.0
+- `@mui/icons-material`: ^7.0.0
+- `@mui/material`: ^7.0.0
+- `@mui/x-date-pickers`: ^7.0.0
+- `@toolpad/core`: ^0.16.0
+- `react`: ^19.0.0
+- `react-dom`: ^19.0.0
+- `react-router-dom`: ^7.0.0
+- `zustand`: ^4.5.0
+
+## Features
+
+### Events
+- **EventBus**: Global event bus for application-wide communication
+- **UserBus**: User-specific event bus with hooks for user management
+- Hooks: `useCurrentUser`, `useUserActions`, `useUserPreferences`
+
+### Navigation
+- **NavigationRegistry**: Microservice registration and routing
+- Navigation stores and hooks for managing application navigation
+- Hooks: `useMicroserviceRoutes`, `useMicroserviceNavigation`, `useNavigationSectionManager`, `useSyncNavigationFilters`
+
+### Common UI Components
+- GridLayout components and utilities
+- Panel system (Expandable, Movable, Resizable, Scrollable)
+- Scroller component
+- LoadingScreen, CenteredHeading, CollapsingButtons, CompoundPanel
+- SpeedDialButton
+
+### Dialogs
+- DialogOpener, FormDialog, ExtendedDialog
+- Dialog registry system
+
+### Notifications
+- Notification component and store
+- Integration with notistack
+
+### Utilities
+- Case conversion utilities
+- Date parsing utilities
+- Cookie utilities
+- API prefix utilities
+- String utilities (slugify)
+
+## Usage
+
+```typescript
+import {
+  // Events
+  EventBus,
+  eventBus,
+  userBus,
+  useCurrentUser,
+  
+  // Navigation
+  registerMicroservice,
+  useMicroserviceNavigation,
+  useNavigationStore,
+  
+  // Components
+  GridItemProvider,
+  ResponsiveGridLayout,
+  Panel,
+  
+  // Dialogs
+  DialogOpener,
+  FormDialog,
+  
+  // Notifications
+  Notifications,
+  useNotificationStore,
+  
+  // Utils
+  parseDate,
+  slugify,
+  getCookie,
+} from '@mui-toolpad-extended-tuni/core';
+```
+
+## License
+
+MIT

package/dist/Dialogs/DialogOpener.d.ts

@@ -0,0 +1,12 @@
+/** @format */
+type dialogType = string;
+type DialogOpenerProps = {
+    title: string;
+    dialogId: dialogType;
+    callOnOpen?: (event: React.MouseEvent<HTMLButtonElement | HTMLElement>) => void;
+    showTitle?: boolean;
+    onOpenDialog?: (dialogId: string) => void;
+    icon?: React.ReactNode;
+};
+declare const DialogOpener: ({ title, dialogId, callOnOpen, showTitle, onOpenDialog, icon, }: DialogOpenerProps) => import("react/jsx-runtime").JSX.Element;
+export default DialogOpener;

package/dist/Dialogs/Dialogs.d.ts

@@ -0,0 +1,6 @@
+/** @format */
+type DialogsProps = {
+    openDialog?: string | null;
+};
+declare const Dialogs: ({ openDialog }: DialogsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default Dialogs;

package/dist/Dialogs/ExtendedDialog.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+type CustomDialogProps = {
+    children: ReactNode;
+    open: boolean;
+    onClose: () => void;
+};
+declare const ExtendedDialog: ({ children, open, onClose, ...dialogProps }: CustomDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default ExtendedDialog;

package/dist/Dialogs/FormDialog.d.ts

@@ -0,0 +1,15 @@
+import { DialogProps } from '@mui/material';
+interface FormDialogProps {
+    onSubmit: (event: React.FormEvent<HTMLFormElement>) => void;
+    title: string;
+    children: React.ReactNode;
+    submitText?: string;
+    disableSubmit?: boolean;
+    maxWidth?: DialogProps["maxWidth"];
+    fullWidth?: boolean;
+    showUnsavedChangesWarning?: boolean;
+    isDirty?: boolean;
+    onClose?: () => void;
+}
+declare const FormDialog: React.FC<FormDialogProps>;
+export default FormDialog;

package/dist/Dialogs/dialogRegistry.d.ts

@@ -0,0 +1,5 @@
+/** @format */
+export declare function registerDialog(dialogId: string, Component: React.ComponentType): void;
+export declare function getDialog(dialogId: string): import('react').ComponentType<{}> | undefined;
+export declare function openDialog(_dialogId: string): void;
+export declare function closeDialog(): void;

package/dist/Events/EventBus.d.ts

@@ -0,0 +1,34 @@
+import { Event } from './types';
+/**
+ * Event Bus for decoupling event producers from consumers.
+ * Modules can publish events and other modules can subscribe to them.
+ * This is a generic event system that any module can use.
+ */
+export declare class EventBus {
+    private static instance;
+    private subscribers;
+    private events;
+    private constructor();
+    static getInstance(): EventBus;
+    /**
+     * Subscribe to event updates
+     */
+    subscribe(callback: (events: Event[]) => void): () => void;
+    /**
+     * Publish events to the bus
+     */
+    publish(sourceId: string, events: Event[]): void;
+    /**
+     * Remove all events from a specific source
+     */
+    removeSource(sourceId: string): void;
+    /**
+     * Get all current events
+     */
+    getAllEvents(): Event[];
+    /**
+     * Clear all events
+     */
+    clear(): void;
+}
+export declare const eventBus: EventBus;

package/dist/Events/UserBus.d.ts

@@ -0,0 +1,110 @@
+import { UserEvent, UserData } from './userTypes';
+/**
+ * Configuration interface for UserBus store methods.
+ * This allows UserBus to work with any user store implementation.
+ */
+export interface UserBusStoreConfig {
+    getUser: () => Promise<void>;
+    updateUser: (userData: UserData) => Promise<UserData>;
+    setUserToUpdate: (user: UserData | null) => void;
+    fetchCourseUsers: (courseId: string) => Promise<void>;
+    logout: () => Promise<void>;
+    getState: () => {
+        user: UserData | null;
+        courseUsers?: UserData[];
+    };
+}
+/**
+ * User Bus for decoupling user state changes from consumers.
+ * Modules can subscribe to user events and react to user state changes.
+ * This follows the same pattern as EventBus but is specifically for user-related events.
+ *
+ * UserBus requires store methods to be configured via configureStore() before use.
+ */
+export declare class UserBus {
+    private static instance;
+    private subscribers;
+    private currentUser;
+    private lastEvent;
+    private storeConfig;
+    private constructor();
+    /**
+     * Configure UserBus with store methods.
+     * This must be called before using store-dependent methods.
+     */
+    configureStore(config: UserBusStoreConfig): void;
+    private getStoreConfig;
+    static getInstance(): UserBus;
+    /**
+     * Subscribe to user event updates
+     * @param callback Function to call when user events occur
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: (event: UserEvent) => void): () => void;
+    /**
+     * Publish a user event to the bus
+     * @param event User event to publish
+     */
+    publish(event: UserEvent): void;
+    /**
+     * Get the current user synchronously
+     * @returns Current user data or null
+     */
+    getCurrentUser(): UserData | null;
+    /**
+     * Get the current user synchronously (alias for getCurrentUser)
+     * @returns Current user data or null
+     */
+    getCurrentUserSync(): UserData | null;
+    /**
+     * Subscribe to user updates and get current user
+     * @param callback Function to call with current user and updates
+     * @returns Unsubscribe function
+     */
+    subscribeToUser(callback: (user: UserData | null) => void): () => void;
+    /**
+     * Get the last user event
+     * @returns Last user event or null
+     */
+    getLastEvent(): UserEvent | null;
+    /**
+     * Clear all user state
+     */
+    clear(): void;
+    /**
+     * Initialize UserBus with current user from store
+     * Should be called by UserEventPublisher on mount
+     */
+    initializeFromStore(): void;
+    /**
+     * Get user from store and publish to bus
+     * Delegates to store.getUser() and publishes event when complete
+     */
+    getUser(): Promise<void>;
+    /**
+     * Update user and publish event
+     * Delegates to store.updateUser() and publishes event
+     */
+    updateUser(userData: UserData): Promise<UserData>;
+    /**
+     * Set user to update (for editing)
+     * Delegates to store.setUserToUpdate()
+     */
+    setUserToUpdate(user: UserData | null): void;
+    /**
+     * Fetch course users
+     * Delegates to store.fetchCourseUsers()
+     */
+    fetchCourseUsers(courseId: string): Promise<void>;
+    /**
+     * Get course users from store
+     * @returns Course users array or undefined
+     */
+    getCourseUsers(): UserData[] | undefined;
+    /**
+     * Logout user and publish event
+     * Delegates to store.logout() and publishes event
+     */
+    logout(): Promise<void>;
+}
+export declare const userBus: UserBus;

package/dist/Events/hooks/useCurrentUser.d.ts

@@ -0,0 +1,11 @@
+import { UserData } from '../userTypes';
+/**
+ * Hook to get current user from UserBus
+ * Automatically updates when user changes via UserBus events
+ *
+ * @returns { user: UserData | null, isLoading: boolean }
+ */
+export declare const useCurrentUser: () => {
+    user: UserData | null;
+    isLoading: boolean;
+};

package/dist/Events/hooks/useUserActions.d.ts

@@ -0,0 +1,15 @@
+import { UserData } from '../userTypes';
+/**
+ * Hook that provides user actions through UserBus
+ * All actions trigger UserBus events when called
+ *
+ * @returns { updateUser, setUserToUpdate, fetchCourseUsers, getUser, logout, getCourseUsers }
+ */
+export declare const useUserActions: () => {
+    updateUser: (userData: UserData) => Promise<UserData>;
+    setUserToUpdate: (user: UserData | null) => void;
+    fetchCourseUsers: (courseId: string) => Promise<void>;
+    getUser: () => Promise<void>;
+    logout: () => Promise<void>;
+    getCourseUsers: () => UserData[] | undefined;
+};

package/dist/Events/hooks/useUserPreferences.d.ts

@@ -0,0 +1,22 @@
+/** @format */
+export interface UserPreferences {
+    navigationType: "direct" | "instances";
+    visibleCourseLists: {
+        isStudent: boolean;
+        isStudentOld: boolean;
+        isTeacher: boolean;
+        isTeacherOld: boolean;
+        available: boolean;
+    };
+    lastVisitedCourses: string[];
+    visibleNavigation: string[];
+}
+/**
+ * Hook to get user preferences from UserBus
+ * Automatically updates when user preferences change via UserBus events
+ *
+ * @returns { preferences: UserPreferences | null }
+ */
+export declare const useUserPreferences: () => {
+    preferences: UserPreferences | null;
+};

package/dist/Events/index.d.ts

@@ -0,0 +1,10 @@
+/** @format */
+export { EventBus, eventBus } from './EventBus';
+export type { Event, EventSource } from './types';
+export { UserBus } from './UserBus';
+export type { UserBusStoreConfig } from './UserBus';
+export type { UserData, UserEvent, UserEventType, PlatformRole, navigationTypes, gender, userId } from './userTypes';
+export { useCurrentUser } from './hooks/useCurrentUser';
+export { useUserPreferences } from './hooks/useUserPreferences';
+export { useUserActions } from './hooks/useUserActions';
+export type { UserPreferences } from './hooks/useUserPreferences';

package/dist/Events/types.d.ts

@@ -0,0 +1,16 @@
+/** @format */
+/**
+ * Generic Event interface that can be used by any module.
+ * This is the base event type for the Events API.
+ */
+export interface Event {
+    id: string;
+    title: string;
+    start: Date | string;
+    end?: Date | string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Event source identifier type for tracking which module published the event
+ */
+export type EventSource = string;

package/dist/Events/userTypes.d.ts

@@ -0,0 +1,79 @@
+/** @format */
+/**
+ * User data type definition.
+ * This is defined in core to avoid circular dependencies.
+ * The Users package will re-export this type from its store.
+ */
+export type userId = string;
+export type navigationTypes = "direct" | "instances";
+export type gender = "male" | "female" | "other";
+export type PlatformRole = "admin" | "developer" | "moderator" | "creator" | "user" | "guest";
+export interface UserData {
+    id: userId;
+    name: string;
+    email: string;
+    gender?: gender;
+    image?: {
+        large: string;
+        medium: string;
+        thumbnail: string;
+    };
+    department?: string;
+    platformRoles: PlatformRole[];
+    privacySettings: {
+        allowAnalytics: boolean;
+        allowPersonalization: boolean;
+        allowCommunications: boolean;
+        allowThirdPartySharing: boolean;
+    };
+    gdprConsent: {
+        accepted: boolean;
+        acceptedDate?: string;
+        lastUpdated: string;
+    };
+    dataRetention: {
+        deleteAccountAfterInactivity?: number;
+        deleteDataAfterAccountDeletion?: number;
+    };
+    preferences: {
+        navigationType: navigationTypes;
+        visibleCourseLists: {
+            isStudent: boolean;
+            isStudentOld: boolean;
+            isTeacher: boolean;
+            isTeacherOld: boolean;
+            available: boolean;
+        };
+        lastVisitedCourses: string[];
+        visibleNavigation: string[];
+    };
+}
+/**
+ * User event types for UserBus communication.
+ * These events are published when user state changes occur.
+ */
+export type UserEventType = "user:loggedIn" | "user:updated" | "user:preferencesChanged" | "user:loggedOut";
+export interface UserEvent {
+    type: UserEventType;
+    user: UserData | null;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UserLoggedInEvent extends UserEvent {
+    type: "user:loggedIn";
+    user: UserData;
+}
+export interface UserUpdatedEvent extends UserEvent {
+    type: "user:updated";
+    user: UserData;
+    previousUser?: UserData;
+}
+export interface UserPreferencesChangedEvent extends UserEvent {
+    type: "user:preferencesChanged";
+    user: UserData;
+    changedPreferences?: string[];
+}
+export interface UserLoggedOutEvent extends UserEvent {
+    type: "user:loggedOut";
+    user: null;
+}

package/dist/Navigation/NavigationBuilder.d.ts

@@ -0,0 +1,7 @@
+import { addSectionProps } from './store/types';
+export declare function setToolbarRegistryFunctions(register: (id: string, component: React.ComponentType) => void, unregister: (id: string, component: React.ComponentType) => void): void;
+type NavigationSectionBuilderProps = {
+    sections: addSectionProps[];
+};
+export declare const NavigationSectionBuilder: React.FC<NavigationSectionBuilderProps>;
+export {};

package/dist/Navigation/NavigationFilter.d.ts

@@ -0,0 +1 @@
+export declare const NavigationFilter: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/Navigation/NavigationRegistry.d.ts

@@ -0,0 +1,116 @@
+import { ComponentType, ReactNode, ReactElement } from 'react';
+import { SvgIconComponent } from '@mui/icons-material';
+/**
+ * Microservice Registry System
+ *
+ * @version 1.3.0
+ *
+ * A flexible system for registering and managing microservices for grid layouts.
+ * Supports dynamic registration, unregistration, and automatic re-rendering.
+ * Optimized to prevent excessive re-rendering.
+ *
+ * Now supports route providers for microservice-agnostic route registration.
+ */
+/**
+ * Route provider function that returns Route elements
+ */
+export type RouteProvider = () => ReactElement[];
+/**
+ * Microservice entry containing both the component and optional props
+ */
+export interface MicroserviceEntry {
+    Component: ComponentType<any>;
+    props?: Record<string, any>;
+    name: string;
+    description?: string;
+    category?: string;
+    iconComponent?: SvgIconComponent;
+    metadata?: {
+        keepVisible?: boolean;
+        order?: number;
+        tags?: string[];
+        showInNavigation?: boolean;
+        route?: {
+            path: string;
+            element?: ReactNode;
+            index?: boolean;
+        };
+    };
+}
+export declare const useMicroserviceRegistryStore: () => {
+    microservices: Map<string, MicroserviceEntry>;
+    routeProviders: Map<string, RouteProvider>;
+    lastUpdate: number;
+};
+/**
+ * Register a new microservice.
+ *
+ * @param id - The unique identifier for this microservice.
+ * @param Component - The React component to render.
+ * @param options - Optional configuration for the microservice including props and metadata.
+ */
+export declare function registerMicroservice(id: string, Component: ComponentType<any>, options?: {
+    props?: Record<string, any>;
+    name?: string;
+    description?: string;
+    category?: string;
+    iconComponent?: SvgIconComponent;
+    metadata?: {
+        keepVisible?: boolean;
+        order?: number;
+        tags?: string[];
+        showInNavigation?: boolean;
+        route?: {
+            path: string;
+            element?: ReactNode;
+            index?: boolean;
+        };
+    };
+}): void;
+/**
+ * Unregister a microservice.
+ *
+ * @param id - The unique identifier for the microservice to remove.
+ */
+export declare function unregisterMicroservice(id: string): void;
+/**
+ * Get a specific microservice by ID.
+ *
+ * @param id - The unique identifier for the microservice.
+ * @returns The microservice entry or undefined if not found.
+ */
+export declare function getMicroservice(id: string): MicroserviceEntry | undefined;
+/**
+ * Get all registered microservices.
+ *
+ * @returns A Map of all registered microservices.
+ */
+export declare function getAllMicroservices(): Map<string, MicroserviceEntry>;
+/**
+ * Get all microservice IDs.
+ *
+ * @returns An array of all registered microservice IDs.
+ */
+export declare function getMicroserviceIds(): string[];
+/**
+ * Check if a microservice is registered.
+ *
+ * @param id - The unique identifier for the microservice.
+ * @returns True if the microservice is registered, false otherwise.
+ */
+export declare function isMicroserviceRegistered(id: string): boolean;
+/**
+ * Register a route provider.
+ * Route providers are functions that return Route elements, allowing microservices
+ * to register complex nested route structures.
+ *
+ * @param id - The unique identifier for this route provider.
+ * @param provider - Function that returns an array of Route elements.
+ */
+export declare function registerRouteProvider(id: string, provider: RouteProvider): void;
+/**
+ * Unregister a route provider.
+ *
+ * @param id - The unique identifier for the route provider to remove.
+ */
+export declare function unregisterRouteProvider(id: string): void;

package/dist/Navigation/hooks/useMicroserviceNavigation.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook that maintains persistent navigation entries for microservices.
+ */
+export declare const useMicroserviceNavigation: () => null;

package/dist/Navigation/hooks/useMicroserviceRoutes.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+/**
+ * Hook that generates routes from registered microservices
+ * @returns Array of Route elements based on registered microservice routes
+ */
+export declare const useMicroserviceRoutes: () => ReactElement<unknown, string | import('react').JSXElementConstructor<any>>[];

package/dist/Navigation/hooks/useNavigationSectionManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Hook that provides a simplified interface for managing navigation sections.
+ * Abstracts away the complexity of the navigation store and filter store interaction.
+ *
+ * @returns {Object} Section management functions
+ * @property {Function} addDynamicSection - Adds or updates a section in navigation
+ */
+interface DynamicSection {
+    header: string;
+    keepVisible?: boolean;
+    pages?: Array<{
+        segment: string;
+        title: string;
+        Icon?: any;
+        description?: string;
+        instances?: string[];
+        microservices?: string[];
+    }>;
+}
+export declare const useNavigationSectionManager: () => {
+    addDynamicSection: (section: DynamicSection) => void;
+};
+export {};

package/dist/Navigation/hooks/useSyncNavigationFilters.d.ts

@@ -0,0 +1 @@
+export declare const useSyncNavigationFilters: () => void;

package/dist/Navigation/store/microserviceUtils.d.ts

@@ -0,0 +1,9 @@
+import { NavigationPageStoreItem, ViewStore } from './types';
+/**
+ * Aggregates microservices from all available sources (app-level + external).
+ * This is microservice-agnostic - it doesn't hard-code specific store types.
+ *
+ * @param state - The navigation store state
+ * @returns Array of all available microservice navigation items
+ */
+export declare const getAllMicroservices: (state: ViewStore) => NavigationPageStoreItem[];

package/dist/Navigation/store/navigationCalculator.d.ts

@@ -0,0 +1,11 @@
+import { NavigationStoreItem, NavigationSection } from './types';
+/**
+ * Calculates the navigation structure from sections.
+ * Pure function that takes sections, order, and visibility and returns a flat navigation array.
+ *
+ * @param sections - Record of navigation sections keyed by section key
+ * @param sectionOrder - Array of section keys in display order
+ * @param visibleSections - Record of section visibility flags
+ * @returns Flat array of navigation items for rendering
+ */
+export declare const calculateNavigationFromSections: (sections: Record<string, NavigationSection>, sectionOrder: string[], visibleSections: Record<string, boolean>) => NavigationStoreItem[];

package/dist/Navigation/store/sectionManager.d.ts

@@ -0,0 +1,9 @@
+import { ViewStore } from './types';
+/**
+ * Updates microservice navigation for all sections.
+ * Orchestrates the update process across all sections and recalculates navigation.
+ *
+ * @param state - The current navigation store state
+ * @returns Updated state with sections and navigation, or null if no changes
+ */
+export declare const updateMicroserviceNavigationForSections: (state: ViewStore) => Partial<ViewStore> | null;