@smartnet360/svelte-components 0.0.124 → 0.0.126

package/dist/core/Auth/auth.svelte.js

@@ -0,0 +1,229 @@
+// Auth state management using Svelte 5 runes
+import { browser } from '$app/environment';
+// Demo mode - enabled via PUBLIC_DEMO_MODE env var (GitHub Pages)
+const DEMO_MODE = import.meta.env.PUBLIC_DEMO_MODE === 'true';
+const DEMO_USERNAME = 'demo';
+const DEMO_PASSWORD = 'demo123';
+// Demo user session (client-side only, no server needed)
+const DEMO_SESSION = {
+    user: {
+        id: 'demo-user',
+        username: 'demo',
+        displayName: 'Demo User',
+        email: 'demo@example.com',
+        groups: ['demo'],
+        loginTime: Date.now()
+    },
+    permissions: [
+        { featureId: 'map-view', canView: true, canEdit: false, canAdmin: false },
+        { featureId: 'coverage-view', canView: true, canEdit: false, canAdmin: false },
+        { featureId: 'charts-view', canView: true, canEdit: false, canAdmin: false },
+        { featureId: 'desktop-view', canView: true, canEdit: false, canAdmin: false },
+        { featureId: 'table-view', canView: true, canEdit: false, canAdmin: false },
+        { featureId: 'antenna-view', canView: true, canEdit: false, canAdmin: false },
+        { featureId: 'site-check', canView: true, canEdit: false, canAdmin: false },
+        { featureId: 'settings-view', canView: true, canEdit: false, canAdmin: false }
+    ],
+    token: 'demo-token',
+    expiresAt: Date.now() + (24 * 60 * 60 * 1000) // 24 hours for demo
+};
+// Default configuration
+const defaultConfig = {
+    apiEndpoint: '/api/auth',
+    devMode: false,
+    storagePrefix: 'rf-tools-auth',
+    sessionTimeout: 8 * 60 * 60 * 1000 // 8 hours
+};
+/**
+ * Create auth state store with Svelte 5 runes
+ * This must be called within a component context or .svelte.ts file
+ */
+export function createAuthState(config = {}) {
+    const cfg = { ...defaultConfig, ...config };
+    // Core state
+    let session = $state(null);
+    let isLoading = $state(false);
+    let error = $state(null);
+    let initialized = $state(false);
+    // Derived state
+    const isAuthenticated = $derived(session !== null && session.expiresAt > Date.now());
+    const user = $derived(session?.user ?? null);
+    const permissions = $derived(session?.permissions ?? []);
+    const token = $derived(session?.token ?? null);
+    // Storage keys
+    const sessionKey = `${cfg.storagePrefix}-session`;
+    /**
+     * Initialize auth state from storage
+     */
+    function initialize() {
+        if (!browser) {
+            initialized = true;
+            return;
+        }
+        try {
+            const stored = localStorage.getItem(sessionKey);
+            if (stored) {
+                const parsed = JSON.parse(stored);
+                if (parsed.expiresAt > Date.now()) {
+                    session = parsed;
+                }
+                else {
+                    localStorage.removeItem(sessionKey);
+                }
+            }
+        }
+        catch (e) {
+            console.error('Failed to restore auth session:', e);
+            localStorage.removeItem(sessionKey);
+        }
+        initialized = true;
+    }
+    /**
+     * Save session to storage
+     */
+    function saveSession(newSession) {
+        session = newSession;
+        if (browser) {
+            localStorage.setItem(sessionKey, JSON.stringify(newSession));
+        }
+    }
+    /**
+     * Clear session
+     */
+    function clearSession() {
+        session = null;
+        if (browser) {
+            localStorage.removeItem(sessionKey);
+        }
+    }
+    /**
+     * Login with credentials
+     */
+    async function login(username, password, agreedToMonitoring) {
+        if (!agreedToMonitoring) {
+            error = 'You must agree to activity monitoring to proceed.';
+            return false;
+        }
+        isLoading = true;
+        error = null;
+        try {
+            // Demo mode: handle authentication client-side (no server needed)
+            if (DEMO_MODE) {
+                if (username === DEMO_USERNAME && password === DEMO_PASSWORD) {
+                    // Create fresh demo session with updated timestamp
+                    const demoSession = {
+                        ...DEMO_SESSION,
+                        user: { ...DEMO_SESSION.user, loginTime: Date.now() },
+                        expiresAt: Date.now() + (24 * 60 * 60 * 1000)
+                    };
+                    saveSession(demoSession);
+                    return true;
+                }
+                else {
+                    error = 'Demo mode: Use username "demo" and password "demo123"';
+                    return false;
+                }
+            }
+            // Normal mode: call server API
+            const response = await fetch(`${cfg.apiEndpoint}/login`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ username, password, agreedToMonitoring })
+            });
+            const data = await response.json();
+            if (data.success && data.session) {
+                saveSession(data.session);
+                return true;
+            }
+            else {
+                error = data.error || 'Authentication failed';
+                return false;
+            }
+        }
+        catch (e) {
+            error = e instanceof Error ? e.message : 'Network error';
+            return false;
+        }
+        finally {
+            isLoading = false;
+        }
+    }
+    /**
+     * Login with dev mode credentials (auto-login)
+     */
+    function loginDev(devUser, devPermissions) {
+        const devSession = {
+            user: devUser,
+            permissions: devPermissions,
+            token: 'dev-token-' + Date.now(),
+            expiresAt: Date.now() + cfg.sessionTimeout
+        };
+        saveSession(devSession);
+    }
+    /**
+     * Logout
+     */
+    async function logout() {
+        isLoading = true;
+        try {
+            // Skip server call in demo mode (no server available)
+            if (!DEMO_MODE && session?.token) {
+                await fetch(`${cfg.apiEndpoint}/logout`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${session.token}`
+                    }
+                }).catch(() => { }); // Ignore errors
+            }
+        }
+        finally {
+            clearSession();
+            isLoading = false;
+        }
+    }
+    /**
+     * Check if user has permission for a feature
+     */
+    function hasPermission(featureId, level = 'view') {
+        const permission = permissions.find(p => p.featureId === featureId);
+        if (!permission)
+            return false;
+        switch (level) {
+            case 'view': return permission.canView;
+            case 'edit': return permission.canEdit ?? false;
+            case 'admin': return permission.canAdmin ?? false;
+            default: return false;
+        }
+    }
+    /**
+     * Check if user can access a route
+     */
+    function canAccessRoute(route, requiredPermission) {
+        if (!isAuthenticated)
+            return false;
+        if (!requiredPermission)
+            return true;
+        return hasPermission(requiredPermission, 'view');
+    }
+    // Initialize on creation
+    initialize();
+    return {
+        // State (getters)
+        get session() { return session; },
+        get isLoading() { return isLoading; },
+        get error() { return error; },
+        get initialized() { return initialized; },
+        get isAuthenticated() { return isAuthenticated; },
+        get user() { return user; },
+        get permissions() { return permissions; },
+        get token() { return token; },
+        // Actions
+        login,
+        loginDev,
+        logout,
+        hasPermission,
+        canAccessRoute,
+        clearError: () => { error = null; }
+    };
+}

package/dist/core/Auth/config.d.ts

@@ -0,0 +1,25 @@
+import type { DevConfig, CategoryInfo, AppDefinition, User, FeatureAccess } from './types.js';
+/**
+ * Default category definitions
+ */
+export declare const DEFAULT_CATEGORIES: CategoryInfo[];
+/**
+ * Default app definitions - all available apps/tools
+ */
+export declare const DEFAULT_APPS: AppDefinition[];
+/**
+ * Default dev user for development mode
+ */
+export declare const DEFAULT_DEV_USER: User;
+/**
+ * Default permissions for dev mode (full access)
+ */
+export declare const DEFAULT_DEV_PERMISSIONS: FeatureAccess[];
+/**
+ * Get full dev configuration
+ */
+export declare function getDevConfig(): DevConfig;
+/**
+ * Check if we're in development mode
+ */
+export declare function isDevMode(): boolean;

package/dist/core/Auth/config.js

@@ -0,0 +1,256 @@
+/**
+ * Default category definitions
+ */
+export const DEFAULT_CATEGORIES = [
+    {
+        id: 'map-tools',
+        title: 'Map Tools',
+        description: 'Geographic visualization and network mapping tools',
+        icon: 'bi-map',
+        color: 'primary'
+    },
+    {
+        id: 'visualization',
+        title: 'Visualization',
+        description: 'Charts, graphs, and data visualization tools',
+        icon: 'bi-bar-chart-line',
+        color: 'success'
+    },
+    {
+        id: 'optimization',
+        title: 'Optimization',
+        description: 'Network optimization and planning tools',
+        icon: 'bi-sliders',
+        color: 'warning'
+    },
+    {
+        id: 'analysis',
+        title: 'Analysis',
+        description: 'Data analysis and reporting tools',
+        icon: 'bi-graph-up',
+        color: 'info'
+    },
+    {
+        id: 'configuration',
+        title: 'Configuration',
+        description: 'System configuration and settings',
+        icon: 'bi-gear',
+        color: 'secondary'
+    },
+    {
+        id: 'demo',
+        title: 'Demos & Examples',
+        description: 'Demo applications and component showcases',
+        icon: 'bi-play-circle',
+        color: 'dark'
+    }
+];
+/**
+ * Default app definitions - all available apps/tools
+ */
+export const DEFAULT_APPS = [
+    // Map Tools
+    {
+        id: 'map-v3-demo',
+        title: 'Network Map',
+        description: 'Interactive cellular network visualization with coverage layers',
+        route: '/apps/map-v3-demo',
+        icon: 'bi-map',
+        category: 'map-tools',
+        requiredPermission: 'map-view',
+        enabled: true,
+        badge: 'New',
+        badgeColor: 'success'
+    },
+    {
+        id: 'coverage-test',
+        title: 'Coverage Analysis',
+        description: 'Analyze network coverage and signal propagation',
+        route: '/apps/coverage-test',
+        icon: 'bi-broadcast',
+        category: 'map-tools',
+        requiredPermission: 'coverage-view',
+        enabled: true
+    },
+    {
+        id: 'map-demo',
+        title: 'Map Demo (Legacy)',
+        description: 'Legacy map component demonstration',
+        route: '/apps/map-demo',
+        icon: 'bi-map-fill',
+        category: 'map-tools',
+        requiredPermission: 'map-view',
+        enabled: true
+    },
+    // Visualization
+    {
+        id: 'charts-demo',
+        title: 'Charts',
+        description: 'Interactive Plotly-based chart visualization system',
+        route: '/apps/demo/charts',
+        icon: 'bi-bar-chart-line',
+        category: 'visualization',
+        requiredPermission: 'charts-view',
+        enabled: true
+    },
+    {
+        id: 'charts-editor',
+        title: 'Chart Editor',
+        description: 'Create and customize chart configurations',
+        route: '/apps/demo/charts/editor',
+        icon: 'bi-pencil-square',
+        category: 'visualization',
+        requiredPermission: 'charts-edit',
+        enabled: true
+    },
+    {
+        id: 'desktop-grid',
+        title: 'Desktop Grid',
+        description: 'Multi-panel layout orchestrator for complex dashboards',
+        route: '/apps/demo/desktop',
+        icon: 'bi-grid-3x3-gap',
+        category: 'visualization',
+        requiredPermission: 'desktop-view',
+        enabled: true
+    },
+    {
+        id: 'cell-table',
+        title: 'Cell Table',
+        description: 'Tabulator-based data table with grouping and filtering',
+        route: '/apps/demo/cell-table',
+        icon: 'bi-table',
+        category: 'visualization',
+        requiredPermission: 'table-view',
+        enabled: true
+    },
+    // Analysis
+    {
+        id: 'antenna-patterns',
+        title: 'Antenna Patterns',
+        description: 'Visualize and analyze antenna radiation patterns',
+        route: '/apps/antenna-patterns',
+        icon: 'bi-broadcast-pin',
+        category: 'analysis',
+        requiredPermission: 'antenna-view',
+        enabled: true
+    },
+    {
+        id: 'site-check',
+        title: 'Site Check',
+        description: 'Site validation and configuration checker',
+        route: '/apps/site-check',
+        icon: 'bi-building-check',
+        category: 'analysis',
+        requiredPermission: 'site-check',
+        enabled: true
+    },
+    // Configuration
+    {
+        id: 'settings-test',
+        title: 'Settings Panel',
+        description: 'Configuration management interface',
+        route: '/apps/settings-test',
+        icon: 'bi-gear-wide-connected',
+        category: 'configuration',
+        requiredPermission: 'settings-view',
+        enabled: true
+    },
+    {
+        id: 'settings-demo',
+        title: 'Settings Demo',
+        description: 'Settings component showcase',
+        route: '/apps/demo/settings-demo',
+        icon: 'bi-sliders2',
+        category: 'configuration',
+        enabled: true
+    },
+    // Demos
+    {
+        id: 'tree-test',
+        title: 'Tree View',
+        description: 'Hierarchical tree navigation component',
+        route: '/apps/demo/tree-test',
+        icon: 'bi-diagram-3',
+        category: 'demo',
+        enabled: true
+    },
+    {
+        id: 'dummy-components',
+        title: 'Component Showcase',
+        description: 'Demo of all available UI components',
+        route: '/apps/demo/dummy-components',
+        icon: 'bi-boxes',
+        category: 'demo',
+        enabled: true
+    },
+    {
+        id: 'charts-tabs',
+        title: 'Charts Tabs Mode',
+        description: 'Charts with tabbed navigation',
+        route: '/apps/demo/charts/tabs',
+        icon: 'bi-window-tab',
+        category: 'demo',
+        enabled: true
+    },
+    {
+        id: 'charts-scrollspy',
+        title: 'Charts Scrollspy',
+        description: 'Charts with scroll-based navigation',
+        route: '/apps/demo/charts/scrollspy',
+        icon: 'bi-arrows-vertical',
+        category: 'demo',
+        enabled: true
+    }
+];
+/**
+ * Default dev user for development mode
+ */
+export const DEFAULT_DEV_USER = {
+    id: 'dev-user',
+    username: 'developer',
+    displayName: 'Developer',
+    email: 'dev@localhost',
+    groups: ['developers', 'admins'],
+    loginTime: Date.now()
+};
+/**
+ * Default permissions for dev mode (full access)
+ */
+export const DEFAULT_DEV_PERMISSIONS = [
+    { featureId: 'map-view', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'coverage-view', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'charts-view', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'charts-edit', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'desktop-view', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'table-view', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'antenna-view', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'site-check', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'settings-view', canView: true, canEdit: true, canAdmin: true },
+    { featureId: 'admin', canView: true, canEdit: true, canAdmin: true }
+];
+/**
+ * Get full dev configuration
+ */
+export function getDevConfig() {
+    return {
+        devMode: true,
+        devUser: DEFAULT_DEV_USER,
+        devPermissions: DEFAULT_DEV_PERMISSIONS,
+        landingPage: {
+            title: 'RF Tool Components',
+            subtitle: 'Network Planning and Visualization Suite',
+            categories: DEFAULT_CATEGORIES,
+            apps: DEFAULT_APPS
+        }
+    };
+}
+/**
+ * Check if we're in development mode
+ */
+export function isDevMode() {
+    // Check environment - in dev server or explicit flag
+    if (typeof import.meta !== 'undefined' && import.meta.env?.DEV) {
+        return true;
+    }
+    return false;
+}

package/dist/core/Auth/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './auth.svelte.js';
+export * from './config.js';
+export { default as LoginForm } from './LoginForm.svelte';

package/dist/core/Auth/index.js

@@ -0,0 +1,5 @@
+// Auth module barrel export
+export * from './types.js';
+export * from './auth.svelte.js';
+export * from './config.js';
+export { default as LoginForm } from './LoginForm.svelte';

package/dist/core/Auth/types.d.ts

@@ -0,0 +1,140 @@
+/**
+ * User information returned after successful authentication
+ */
+export interface User {
+    /** Unique user identifier */
+    id: string;
+    /** Username used for login */
+    username: string;
+    /** Display name */
+    displayName: string;
+    /** User email (from LDAP) */
+    email?: string;
+    /** Groups/roles from LDAP */
+    groups?: string[];
+    /** Timestamp of login */
+    loginTime: number;
+}
+/**
+ * Access permission for a specific feature/app
+ */
+export interface FeatureAccess {
+    /** Feature/app identifier */
+    featureId: string;
+    /** Whether user can view this feature */
+    canView: boolean;
+    /** Whether user can edit/modify */
+    canEdit?: boolean;
+    /** Whether user can administrate */
+    canAdmin?: boolean;
+}
+/**
+ * User session with permissions
+ */
+export interface UserSession {
+    /** Authenticated user info */
+    user: User;
+    /** Access permissions for features */
+    permissions: FeatureAccess[];
+    /** Session token (for API calls) */
+    token: string;
+    /** Token expiration timestamp */
+    expiresAt: number;
+}
+/**
+ * Login credentials
+ */
+export interface LoginCredentials {
+    username: string;
+    password: string;
+    /** User agreed to activity monitoring */
+    agreedToMonitoring: boolean;
+}
+/**
+ * Login response from API
+ */
+export interface LoginResponse {
+    success: boolean;
+    session?: UserSession;
+    error?: string;
+}
+/**
+ * Auth configuration
+ */
+export interface AuthConfig {
+    /** API endpoint for authentication */
+    apiEndpoint: string;
+    /** Enable development mode (auto-login) */
+    devMode: boolean;
+    /** Session storage key prefix */
+    storagePrefix: string;
+    /** Session timeout in milliseconds */
+    sessionTimeout: number;
+}
+/**
+ * App/Feature definition for landing page
+ */
+export interface AppDefinition {
+    /** Unique identifier */
+    id: string;
+    /** Display title */
+    title: string;
+    /** Short description */
+    description: string;
+    /** Route path */
+    route: string;
+    /** Bootstrap icon class (e.g., 'bi-map') */
+    icon: string;
+    /** Category for grouping */
+    category: AppCategory;
+    /** Required permission to access */
+    requiredPermission?: string;
+    /** Whether app is enabled */
+    enabled: boolean;
+    /** Badge text (e.g., 'New', 'Beta') */
+    badge?: string;
+    /** Badge color class */
+    badgeColor?: string;
+}
+/**
+ * App category for grouping in landing page
+ */
+export type AppCategory = 'map-tools' | 'visualization' | 'optimization' | 'analysis' | 'configuration' | 'demo';
+/**
+ * Category metadata for display
+ */
+export interface CategoryInfo {
+    id: AppCategory;
+    title: string;
+    description: string;
+    icon: string;
+    color: string;
+}
+/**
+ * Landing page configuration
+ */
+export interface LandingPageConfig {
+    /** Application title */
+    title: string;
+    /** Subtitle/description */
+    subtitle: string;
+    /** Logo URL (optional) */
+    logo?: string;
+    /** Categories to display */
+    categories: CategoryInfo[];
+    /** Apps to display */
+    apps: AppDefinition[];
+}
+/**
+ * Development mode configuration (from config.json)
+ */
+export interface DevConfig {
+    /** Enable dev mode */
+    devMode: boolean;
+    /** Auto-login user for dev mode */
+    devUser: User;
+    /** Dev mode permissions */
+    devPermissions: FeatureAccess[];
+    /** Landing page config */
+    landingPage: LandingPageConfig;
+}

package/dist/core/Auth/types.js

@@ -0,0 +1,2 @@
+// Auth module types
+export {};