mui-toolpad-extended-tuni 2.1.0 → 3.0.0

package/dist/src/LMSToolpad/components/Courses/store/useCourseStore.d.ts

@@ -0,0 +1,146 @@
+import { fetchState } from '../../../interfaces';
+export type courseRole = "student" | "teacher" | "guest";
+export type visibilityMode = "public" | "enrolled" | "private";
+export type courseEventType = "lecture" | "exercise" | "exam" | "deadline" | "other";
+export type courseEventFrequency = "daily" | "weekly" | "biweekly";
+export type legalBasis = "consent" | "contract" | "legal_obligation" | "legitimate_interests";
+export type enrollmentStatus = "enrolled" | "pending" | "rejected";
+export interface EnrollmentData {
+    courseId: string;
+    userId: string;
+    name: string;
+    email: string;
+    role: courseRole;
+    status: enrollmentStatus;
+}
+interface CourseEvent {
+    id: string;
+    type: courseEventType;
+    title: string;
+    description?: string;
+    startTime: string;
+    endTime?: string;
+    location?: string;
+    teachers?: EnrollmentData[];
+    recurring?: {
+        frequency: courseEventFrequency;
+        until: string;
+        exceptions?: string[];
+    };
+    maxParticipants?: number;
+    requiresRegistration?: boolean;
+}
+export type courseRelationType = "prerequisite" | "recommended" | "parallel" | "continues_from" | "alternative_to" | "part_of" | "prepares_for";
+export type courseLevel = "basic" | "intermediate" | "advanced";
+export interface CourseRelation {
+    code: string;
+    type: courseRelationType;
+    description?: string;
+    required?: boolean;
+}
+export interface CourseRaw {
+    title: string;
+    description: string;
+    code: string;
+    instance: string;
+    ltiLoginUrl?: string;
+    services?: string[];
+    image?: {
+        large: string;
+        medium: string;
+        thumbnail: string;
+    };
+    startDate: string | null;
+    endDate: string | null;
+    visibility: {
+        mode: visibilityMode;
+        startDate: string | null;
+        endDate: string | null;
+    };
+    events: {
+        [key in courseEventType]: CourseEvent[];
+    };
+    tags?: string[];
+    language?: string;
+    dataProcessing: {
+        purposes: string[];
+        retention: number;
+        thirdPartyProcessors: {
+            name: string;
+            purpose: string;
+            dataShared: string[];
+        }[];
+        specialCategories: boolean;
+        legalBasis: legalBasis;
+    };
+    enrollment?: {
+        startDate: string | null;
+        endDate: string | null;
+        status: {
+            open: boolean;
+            maxStudents?: number;
+        };
+    };
+    data?: {
+        myData?: {
+            role: courseRole;
+            status: enrollmentStatus;
+        };
+        enrollmentData?: EnrollmentData[];
+    };
+    relationships?: {
+        prerequisites: CourseRelation[];
+        continuations: CourseRelation[];
+        alternatives: CourseRelation[];
+        related: CourseRelation[];
+    };
+    studyModule?: {
+        name: string;
+        order?: number;
+        credits: number;
+        level: courseLevel;
+    };
+}
+export interface Course extends CourseRaw {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const courseTemplate: CourseRaw;
+interface CourseStore {
+    fetchState: fetchState;
+    currentCourseUrl: string;
+    currentCourse: Course | null;
+    courseToUpdate: Course | null;
+    courses: Course[];
+    currentCourseCode: string | null;
+    setCourseToUpdate: (course: Course | null) => void;
+    setCurrentCourseUrl: (url: string) => void;
+    setCurrentCourse: (course: Course | null) => void;
+    setCurrentCourseCode: (code: string | null) => void;
+    updateStateCourse: (course: Course) => Promise<Course>;
+    getCourseByUrl: (url: string) => void;
+    getCourses: () => void;
+    learningCourses: Course[];
+    learningCoursesOld: Course[];
+    teachingCourses: Course[];
+    teachingCoursesOld: Course[];
+    availableCourses: Course[];
+}
+/**
+ * Course management store with enhanced instance handling.
+ *
+ * @version 2.1.0
+ * @updates
+ * - Added support for course codes and instances
+ * - Enhanced course filtering capabilities
+ * - Added currentCourseCode state
+ * - Updated Course interface with new fields
+ * - Added instance-specific state management
+ *
+ * @breaking-changes
+ * - Updated Course interface requires code and instance fields
+ * - Changed course identification logic to use code + instance
+ */
+declare const useCourseStore: import('zustand/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<CourseStore>>;
+export default useCourseStore;

package/dist/{LMSToolpad → src/LMSToolpad/components/Courses}/utils/courseFilters.d.ts

@@ -1,5 +1,11 @@
-/** @format */
 import { Course } from '../store/useCourseStore';
+export type CourseGroups = {
+    isStudent: Course[];
+    isStudentOld: Course[];
+    isTeacher: Course[];
+    isTeacherOld: Course[];
+    available: Course[];
+};
 export declare const filterUniqueCourses: (courses: Course[]) => Course[];
 export declare const isActiveCourse: (course: Course) => boolean;
 export declare const isActivecode: (courses: Course[], code: string) => boolean;
@@ -12,3 +18,4 @@ export declare const groupCoursesByActivity: (courses: Course[], skipUnique?: bo
     active: Course[];
     inactive: Course[];
 };
+export declare const groupCoursesByEnrollment: (courses: Course[]) => CourseGroups;

package/dist/{LMSToolpad → src/LMSToolpad}/components/Dialogs/DialogOpener.d.ts

@@ -1,4 +1,3 @@
-/** @format */
 import { dialogType } from '../../store/useDialogStore';
 type DialogOpenerProps = {
     title: string;

package/dist/src/LMSToolpad/components/Dialogs/Dialogs.d.ts

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

package/dist/src/LMSToolpad/components/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/{LMSToolpad → src/LMSToolpad}/components/Dialogs/FormDialog.d.ts

@@ -1,10 +1,14 @@
-/** @format */
+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;
 }
 declare const FormDialog: React.FC<FormDialogProps>;
 export default FormDialog;

package/dist/src/LMSToolpad/components/Dialogs/dialogRegistry.d.ts

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

package/dist/src/LMSToolpad/components/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/src/LMSToolpad/components/Events/UserBus.d.ts

@@ -0,0 +1,111 @@
+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.
+ * This allows it to work without direct dependencies on user store implementations.
+ */
+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/src/LMSToolpad/components/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/src/LMSToolpad/components/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/src/LMSToolpad/components/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/src/LMSToolpad/components/Events/index.d.ts

@@ -0,0 +1,10 @@
+/** @format */
+export { EventBus, eventBus } from './EventBus';
+export type { Event, EventSource } from './types';
+export { UserBus, 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/src/LMSToolpad/components/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/src/LMSToolpad/components/Events/userTypes.d.ts

@@ -0,0 +1,78 @@
+/** @format */
+/**
+ * User data type definition.
+ * This is defined here to avoid circular dependencies.
+ */
+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/{LMSToolpad → src/LMSToolpad}/components/IconWithBadge.d.ts

@@ -1,4 +1,3 @@
-/** @format */
 import { SxProps, Theme } from '@mui/material/styles';
 type IconWithBadgeProps = {
     Icon: React.FC;

package/dist/{LMSToolpad/components → src/LMSToolpad/components/Microservices}/MicroserviceNavigationBuilder.d.ts

@@ -1,10 +1,10 @@
-/** @format */
-import { NavigationPageStoreItem } from '../store/useNavigationStore';
+import { NavigationPageStoreItem } from '../Navigation/store/types';
 export type BuildMicroServiceNavigationProps = {
     segment: string;
     title: string;
     description: string;
     icon: any;
+    view?: React.ComponentType;
     forRoles: string[];
     children?: NavigationPageStoreItem[];
 };
@@ -42,4 +42,4 @@ export type BuildMicroServiceNavigationProps = {
  * });
  * ```
  */
-export declare const buildMicroServiceNavigation: ({ segment, title, description, icon, forRoles, children, }: BuildMicroServiceNavigationProps) => NavigationPageStoreItem[];
+export declare const buildMicroServiceNavigation: ({ segment, title, description, icon, view, forRoles, children, }: BuildMicroServiceNavigationProps) => NavigationPageStoreItem[];

package/dist/src/LMSToolpad/components/Microservices/MicroserviceSubsections.d.ts

@@ -0,0 +1,9 @@
+import { NavigationPageStoreItem } from '../Navigation/store/types';
+import { default as React } from 'react';
+/**
+ * Sub-sections navigation component for tool pages
+ */
+declare const SubSections: React.FC<{
+    children: NavigationPageStoreItem[];
+}>;
+export default SubSections;

package/dist/src/LMSToolpad/components/Microservices/Microservices.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+/**
+ * Core component for handling top-level app routing and microservices.
+ *
+ * @version 3.1.0
+ * @breaking-changes
+ * - Course routing has been moved to CourseMicroservice component
+ * - This component is now microservice-agnostic - it doesn't directly import course routes
+ * - Course routes register themselves via CourseRoutesProvider using NavigationRegistry
+ *
+ * Architecture:
+ * - Microservices handles: /, /help, /contact, dynamic microservices (via NavigationRegistry)
+ * - Course routes register themselves as route providers via CourseRoutesProvider
+ * - All routes are retrieved through useMicroserviceRoutes() which includes route providers
+ * - CourseMicroservice handles: /:code, /:code/:instance, /:code/:instance/:microservice
+ * - Course microservices are managed by CourseMicroservice component via context (not tightly coupled here)
+ *
+ * @component
+ * @param {Object} props
+ * @param {React.ReactNode} props.children - Child components (e.g., CourseMicroservice)
+ */
+declare const Microservices: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default Microservices;

package/dist/src/LMSToolpad/components/Microservices/types.d.ts

@@ -0,0 +1,12 @@
+/** @format */
+/**
+ * Configuration interface for microservices
+ *
+ * Used to define microservice metadata including routing, component, and navigation building.
+ */
+export interface MicroserviceConfig {
+    path: string;
+    Component: React.ComponentType;
+    fetchHooks?: Array<(courseId: string) => void>;
+    buildNavigation: (courseId: string, isTeacher: boolean) => any[];
+}

package/dist/src/LMSToolpad/components/Navigation/NavigationBuilder.d.ts

@@ -0,0 +1,6 @@
+import { addSectionProps } from './store/types';
+type NavigationSectionBuilderProps = {
+    sections: addSectionProps[];
+};
+export declare const NavigationSectionBuilder: React.FC<NavigationSectionBuilderProps>;
+export {};

package/dist/src/LMSToolpad/components/Navigation/NavigationFilter.d.ts

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