@mui-toolpad-extended-tuni/main 3.2.0

package/dist/interfaces.d.ts

@@ -0,0 +1 @@
+export type fetchState = "idle" | "loading" | "error" | "success";

package/dist/layout/Content/PageContent.d.ts

@@ -0,0 +1,5 @@
+/** @format */
+declare const PageContent: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default PageContent;

package/dist/layout/Toolbars/AppToolbar/Account.d.ts

@@ -0,0 +1,2 @@
+/** @format */
+export declare const ToolbarAccount: () => import("react/jsx-runtime").JSX.Element;

package/dist/layout/Toolbars/AppToolbar/CollapsibleMenu.d.ts

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

package/dist/layout/Toolbars/AppToolbar/Logo.d.ts

@@ -0,0 +1,2 @@
+/** @format */
+export declare const Logo: () => import("react/jsx-runtime").JSX.Element;

package/dist/layout/Toolbars/AppToolbar/RegisteredAppTools.d.ts

@@ -0,0 +1,11 @@
+/** @format */
+/**
+ * A component that renders app toolbar actions registered under a fixed "global" key
+ * or using location.pathname for route-specific app actions.
+ *
+ * @version 1.1.0
+ * @updates
+ * - Added support for passing props to toolbar components
+ */
+declare const RegisteredAppTools: () => import("react/jsx-runtime").JSX.Element | null;
+export default RegisteredAppTools;

package/dist/layout/Toolbars/AppToolbar/SearchBar.d.ts

@@ -0,0 +1,6 @@
+/** @format */
+interface SearchBarProps {
+    onExpandChange?: (expanded: boolean) => void;
+}
+declare const SearchBar: ({ onExpandChange }: SearchBarProps) => import("react/jsx-runtime").JSX.Element;
+export default SearchBar;

package/dist/layout/Toolbars/PageToolbar/RegisteredPageTools.d.ts

@@ -0,0 +1,37 @@
+/** @format */
+/**
+ * PageToolbar Component
+ *
+ * @version 3.1.0
+ *
+ * A dynamic toolbar component that renders actions based on the current route.
+ * Automatically updates when actions are registered or unregistered.
+ *
+ * Features:
+ * - Route-based action rendering
+ * - Dynamic action registration/unregistration
+ * - Automatic re-rendering on changes
+ * - Support for custom toolbar overrides
+ * - Support for passing props to toolbar components
+ *
+ * @example
+ * ```tsx
+ * // In your app layout
+ * <AppLayout>
+ *   <PageToolbar />
+ *   {children}
+ * </AppLayout>
+ *
+ * // Register actions in your components
+ * useEffect(() => {
+ *   registerToolbarAction('/my-route', MyAction);
+ *   return () => unregisterToolbarAction('/my-route', MyAction);
+ * }, []);
+ *
+ * // Register with props
+ * registerPageToolbarAction('/my-route', MyAction, { data: 'some-data' });
+ * ```
+ */
+declare const RegisteredPageTools: () => import("react/jsx-runtime").JSX.Element | null;
+export declare const HeaderWithPageRegistryToolbar: () => import("react/jsx-runtime").JSX.Element;
+export default RegisteredPageTools;

package/dist/layout/Toolbars/toolbarRegistry.d.ts

@@ -0,0 +1,117 @@
+import { ComponentType } from 'react';
+/**
+ * Toolbar Registry System
+ *
+ * @version 3.1.0
+ *
+ * A flexible system for registering and managing toolbar actions based on routes.
+ * Supports dynamic registration, unregistration, and automatic re-rendering.
+ * Now with support for passing props to registered components.
+ *
+ * @example
+ * ```tsx
+ * // Register a toolbar action
+ * registerToolbarAction('/my-route', MyActionComponent);
+ *
+ * // Register with props
+ * registerToolbarAction('/my-route', MyActionComponent, { some: 'props' });
+ *
+ * // Clean up when component unmounts
+ * useEffect(() => {
+ *   registerToolbarAction('/my-route', MyActionComponent);
+ *   return () => unregisterToolbarAction('/my-route', MyActionComponent);
+ * }, []);
+ * ```
+ */
+/**
+ * Toolbar entry containing both the component and optional props
+ */
+export interface ToolbarEntry {
+    Component: ComponentType<any>;
+    props?: Record<string, any>;
+}
+/**
+ * Register a new page toolbar action for a specific route.
+ *
+ * @param path - The route path where this action should appear.
+ * @param Component - The React component to render in the page toolbar.
+ * @param props - Optional props to pass to the component.
+ *
+ * @example
+ * registerPageToolbarAction('/my-route', MyPageAction);
+ * registerPageToolbarAction('/my-route', MyPageAction, { color: 'primary' });
+ */
+export declare function registerPageToolbarAction(path: string, Component: ComponentType<any>, props?: Record<string, any>): void;
+/**
+ * Unregister a page toolbar action from a specific route.
+ *
+ * @param path - The route path to remove the action from.
+ * @param Component - The React component to remove.
+ *
+ * @example
+ * unregisterPageToolbarAction('/my-route', MyPageAction);
+ */
+export declare function unregisterPageToolbarAction(path: string, Component: ComponentType<any>): void;
+/**
+ * Get all registered page toolbar actions for a specific route.
+ *
+ * @param path - The route path to get the actions for.
+ * @returns An array of registered page toolbar action entries.
+ *
+ * @example
+ * const actions = getPageToolbarActions('/my-route');
+ */
+export declare function getPageToolbarActions(path: string): ToolbarEntry[];
+/**
+ * Clear all registered page toolbar actions for a specific route.
+ *
+ * @param path - The route path to clear the actions for.
+ *
+ * @example
+ * clearPageToolbarActions('/my-route');
+ */
+export declare function clearPageToolbarActions(path: string): void;
+/**
+ * Register a new app toolbar action for a specific route or global key.
+ *
+ * @param path - The key or route where this action should appear.
+ * @param Component - The React component to render in the app toolbar.
+ * @param props - Optional props to pass to the component.
+ *
+ * @example
+ * registerAppToolbarAction('global', MyAppAction);
+ * registerAppToolbarAction('global', MyAppAction, { variant: 'outlined' });
+ */
+export declare function registerAppToolbarAction(path: string, Component: ComponentType<any>, props?: Record<string, any>): void;
+/**
+ * Unregister an app toolbar action from a specific route or global key.
+ *
+ * @param path - The key or route to remove the action from.
+ * @param Component - The React component to remove.
+ *
+ * @example
+ * unregisterAppToolbarAction('global', MyAppAction);
+ */
+export declare function unregisterAppToolbarAction(path: string, Component: ComponentType<any>): void;
+/**
+ * Get all registered app toolbar actions for a specific route or global key.
+ *
+ * @param path - The key or route to get the actions for.
+ * @returns An array of registered app toolbar action entries.
+ *
+ * @example
+ * const actions = getAppToolbarActions('global');
+ */
+export declare function getAppToolbarActions(path: string): ToolbarEntry[];
+/**
+ * Clear all registered app toolbar actions for a specific route or global key.
+ *
+ * @param path - The key or route to clear the actions for.
+ *
+ * @example
+ * clearAppToolbarActions('global');
+ */
+export declare function clearAppToolbarActions(path: string): void;
+export declare const useToolbarRegistryStore: () => {
+    version: number;
+};

package/dist/layout/sidebar/Footer.d.ts

@@ -0,0 +1,3 @@
+import { SidebarFooterProps } from '@toolpad/core';
+declare function SidebarFooter({ mini }: SidebarFooterProps): import("react/jsx-runtime").JSX.Element;
+export default SidebarFooter;

package/dist/network/axiosConfig.d.ts

@@ -0,0 +1,4 @@
+/** @format */
+export declare const csrftoken: string | null;
+declare const axiosInstance: Axios.AxiosInstance;
+export default axiosInstance;

package/dist/store/useDialogStore.d.ts

@@ -0,0 +1,9 @@
+/** @format */
+export type dialogType = string | null;
+type DialogState = {
+    openDialog: dialogType;
+    setOpenDialog: (dialog: dialogType | null) => void;
+    closeDialog: () => void;
+};
+declare const useDialogStore: import('zustand/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<DialogState>>;
+export default useDialogStore;

package/dist/store/usePlatformStore.d.ts

@@ -0,0 +1,165 @@
+import { Layouts } from 'react-grid-layout';
+export interface AuthSettings {
+    allowedAuthMethods: ("local" | "google" | "microsoft" | "shibboleth")[];
+    minimumPasswordLength: number;
+    requireEmailVerification: boolean;
+    allowSelfRegistration: boolean;
+    defaultUserRole: PlatformRole;
+}
+export type PlatformRole = "admin" | "developer" | "moderator" | "creator" | "user" | "guest";
+export type visibilityMode = "public" | "enrolled" | "private";
+export interface CourseSettings {
+    courseCreation: {
+        requiredRoles: PlatformRole[];
+        requireApproval: boolean;
+    };
+    defaultCourseVisibility: visibilityMode;
+    defaultEnrollmentDuration: number;
+    courseCategories: string[];
+}
+export interface AISettings {
+    enabled: boolean;
+    providers: {
+        openai: {
+            enabled: boolean;
+            apiKey?: string;
+            modelName: string;
+            maxTokens: number;
+            temperature: number;
+        };
+        anthropic: {
+            enabled: boolean;
+            apiKey?: string;
+            modelName: string;
+        };
+        local: {
+            enabled: boolean;
+            endpoint: string;
+        };
+    };
+    features: {
+        autoGrading: boolean;
+        plagiarismDetection: boolean;
+        contentGeneration: boolean;
+        studentAssistant: boolean;
+        teacherAssistant: boolean;
+    };
+    moderationSettings: {
+        enabled: boolean;
+        filterProfanity: boolean;
+        filterSensitiveContent: boolean;
+        maxQueriesPerHour: number;
+    };
+    agentConfigurations: {
+        agent: "openai" | "anthropic" | "local" | string;
+        assigned: string[];
+        apiKey?: string;
+        modelName?: string;
+        apiUrl?: string;
+    }[];
+}
+export interface NotificationSettings {
+    emailNotifications: boolean;
+    pushNotifications: boolean;
+    smtpSettings?: {
+        host: string;
+        port: number;
+        secure: boolean;
+        auth: {
+            user: string;
+            pass: string;
+        };
+    };
+}
+export interface Platform {
+    name: string;
+    description: string;
+    contactEmail: string;
+    supportUrl: string;
+    darkMode: {
+        enabled: boolean;
+        default: boolean;
+    };
+    auth: AuthSettings;
+    courses: CourseSettings;
+    ai: AISettings;
+    notifications: NotificationSettings;
+    analytics: {
+        enabled: boolean;
+        provider?: string;
+        trackingId?: string;
+    };
+    maintenance: {
+        enabled: boolean;
+        message: string;
+    };
+    storage: {
+        maxFileSize: number;
+        allowedFileTypes: string[];
+        totalStorageLimit: number;
+    };
+    features: {
+        forums: boolean;
+        wiki: boolean;
+        chat: boolean;
+        videoConference: boolean;
+        peerReview: boolean;
+        gamification: boolean;
+    };
+    admins: {
+        emails: string[];
+        invitePending: string[];
+    };
+    privacy: {
+        gdprEnabled: boolean;
+        dataRetentionPeriod: number;
+        defaultPrivacySettings: {
+            allowAnalytics: boolean;
+            allowPersonalization: boolean;
+            allowCommunications: boolean;
+            allowThirdPartySharing: boolean;
+        };
+        privacyPolicy: {
+            url: string;
+            lastUpdated: string;
+            version: string;
+        };
+        cookieSettings: {
+            necessary: boolean;
+            functional: boolean;
+            analytics: boolean;
+            advertising: boolean;
+            expiryDays: number;
+        };
+        dataProcessingAgreements: {
+            thirdParties: {
+                name: string;
+                purpose: string;
+                dataShared: string[];
+                location: string;
+            }[];
+        };
+    };
+    interface: {
+        layout: Layouts;
+    };
+}
+interface PlatformSettingsStore {
+    platform: Platform;
+    platformToUpdate: Platform | null;
+    updatePlatform: (newPlatform: Platform) => void;
+    updateAISettings: (newAISettings: Partial<AISettings>) => void;
+    resetToDefaults: () => void;
+}
+export declare const usePlatformStore: import('zustand/traditional').UseBoundStoreWithEqualityFn<Omit<import('zustand').StoreApi<PlatformSettingsStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<PlatformSettingsStore, PlatformSettingsStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: PlatformSettingsStore) => void) => () => void;
+        onFinishHydration: (fn: (state: PlatformSettingsStore) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<PlatformSettingsStore, PlatformSettingsStore>>;
+    };
+}>;
+export {};

package/dist/store/useThemeStore.d.ts

@@ -0,0 +1,184 @@
+import { Components, Theme, PaletteMode, PaletteOptions } from '@mui/material/styles';
+import { ColorSchemePreference } from '../../../core/src';
+export interface TypographyVariantStyle extends Partial<React.CSSProperties> {
+}
+export interface ThemeTypography {
+    fontFamily: string;
+    h1: TypographyVariantStyle;
+    h2: TypographyVariantStyle;
+    h3: TypographyVariantStyle;
+    h4: TypographyVariantStyle;
+    h5: TypographyVariantStyle;
+    h6: TypographyVariantStyle;
+    subtitle1: TypographyVariantStyle;
+    subtitle2: TypographyVariantStyle;
+    body1: TypographyVariantStyle;
+    body2: TypographyVariantStyle;
+    button: TypographyVariantStyle;
+    caption: TypographyVariantStyle;
+    overline: TypographyVariantStyle;
+}
+export interface shape {
+    borderRadius: number;
+}
+export interface colorScheme {
+    palette: PaletteOptions & {
+        mode: PaletteMode;
+        background: {
+            default: string;
+            paper: string;
+        };
+        primary: {
+            main: string;
+            light: string;
+            dark: string;
+            contrastText: string;
+        };
+        secondary: {
+            main: string;
+            light: string;
+            dark: string;
+            contrastText: string;
+        };
+        error: {
+            main: string;
+            light: string;
+            dark: string;
+            contrastText: string;
+        };
+        warning: {
+            main: string;
+            light: string;
+            dark: string;
+            contrastText: string;
+        };
+        info: {
+            main: string;
+            light: string;
+            dark: string;
+            contrastText: string;
+        };
+        success: {
+            main: string;
+            light: string;
+            dark: string;
+            contrastText: string;
+        };
+        text: {
+            primary: string;
+            secondary: string;
+            disabled: string;
+        };
+        divider: string;
+    };
+}
+export interface ThemeBreakpoints {
+    values: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+    };
+}
+export interface ThemeComponents {
+    MuiButton: {
+        styleOverrides: {
+            root: {
+                textTransform: string;
+                borderRadius: number;
+            };
+        };
+    };
+    MuiPaper: {
+        styleOverrides: {
+            root: {
+                backgroundImage: string;
+            };
+        };
+    };
+    MuiDialog: {
+        styleOverrides: {
+            paper: {
+                borderRadius: number;
+            };
+        };
+    };
+    MuiCard: {
+        styleOverrides: {
+            root: {
+                borderRadius: number;
+            };
+        };
+    };
+}
+export interface ThemeTransitions {
+    easing: {
+        easeInOut: string;
+        easeOut: string;
+        easeIn: string;
+        sharp: string;
+    };
+    duration: {
+        shortest: number;
+        shorter: number;
+        short: number;
+        standard: number;
+        complex: number;
+        enteringScreen: number;
+        leavingScreen: number;
+    };
+}
+export interface ThemezIndex {
+    mobileStepper: number;
+    fab: number;
+    speedDial: number;
+    appBar: number;
+    drawer: number;
+    modal: number;
+    snackbar: number;
+    tooltip: number;
+}
+interface ThemeTemplate {
+    cssVariables: {
+        colorSchemeSelector: string;
+    };
+    defaultColorScheme: 'light' | 'dark';
+    typography: ThemeTypography;
+    shape: shape;
+    spacing: number;
+    colorSchemes: {
+        light: colorScheme;
+        dark: colorScheme;
+    };
+    breakpoints: ThemeBreakpoints;
+    components: Partial<Components<Theme>>;
+    transitions: ThemeTransitions;
+    zIndex: ThemezIndex;
+}
+export declare const ThemeTemplate: ThemeTemplate;
+export type AppTheme = ThemeTemplate;
+interface ThemeStore {
+    colorSchemePreference: ColorSchemePreference;
+    setColorSchemePreference: (preference: ColorSchemePreference) => void;
+    getTheme: () => AppTheme;
+    updateTheme: (updates: AppTheme) => void;
+    resetTheme: () => void;
+}
+/**
+ * Theme management store with support for custom themes and dark mode.
+ *
+ * @version 2.0.0
+ * @updates
+ * - Color scheme preference stored in cookie (light/dark/system)
+ * - Theme colors always come from ThemeTemplate (not persisted)
+ * - System preference detection for 'system' mode
+ *
+ * @features
+ * - Theme customization (colors, typography, etc.)
+ * - Color scheme preference management (cookie-based)
+ * - System preference detection
+ * - Always uses ThemeTemplate for base colors
+ */
+export declare const useThemeStore: import('zustand/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<ThemeStore>>;
+export {};

package/dist/store/useToolbarStore.d.ts

@@ -0,0 +1,8 @@
+/** @format */
+export type toolbarType = string | null;
+type ToolbarState = {
+    currentToolbar: toolbarType;
+    setCurrentToolbar: (toolbar: toolbarType) => void;
+};
+declare const useToolbarStore: import('zustand/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<ToolbarState>>;
+export default useToolbarStore;

package/dist/theme/EduMLTheme.d.ts

@@ -0,0 +1,2 @@
+/** @format */
+export declare const EduMLTheme: Omit<import('@mui/material').Theme, "applyStyles"> & import('@mui/material').CssVarsTheme;

package/dist/tools/ErrorBoundary.d.ts

@@ -0,0 +1,14 @@
+import { Component, ErrorInfo, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+}
+interface State {
+    hasError: boolean;
+}
+declare class ErrorBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(_: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+}
+export default ErrorBoundary;

package/dist/tools/NullStateWarning.d.ts

@@ -0,0 +1,8 @@
+type NullStateWarningProps = {
+    states: {
+        [key: string]: any;
+    }[];
+    children: React.ReactNode;
+};
+declare const NullStateWarning: ({ states, children }: NullStateWarningProps) => import("react/jsx-runtime").JSX.Element;
+export default NullStateWarning;

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@mui-toolpad-extended-tuni/main",
+  "version": "3.2.0",
+  "description": "Main package for MUI Toolpad Extended TUNI - provides ToolpadProvider, LMS components, and platform features",
+  "author": "Jaakko Rajala",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jalez/mui-toolpad-extended-tuni.git",
+    "directory": "packages/main"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.es.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "react",
+    "mui",
+    "toolpad",
+    "education",
+    "tuni",
+    "main"
+  ],
+  "license": "MIT",
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc && vite build",
+    "dev": "vite build --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@mui-toolpad-extended-tuni/core": "^3.1.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/modifiers": "^9.0.0",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@fontsource/roboto": "^5.0.14",
+    "axios": "^1.7.9",
+    "chart.js": "^4.5.1",
+    "d3-force": "^3.0.0",
+    "lodash": "^4.17.21",
+    "react-chartjs-2": "^5.2.0",
+    "react-colorful": "^5.6.1",
+    "react-grid-layout": "^1.5.0",
+    "styled-components": "^6.1.0",
+    "uuid": "^10.0.0"
+  },
+  "peerDependencies": {
+    "@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"
+  }
+}