@smartnet360/svelte-components 0.0.123 → 0.0.125

package/dist/apps/antenna-tools/utils/msi-parser.d.ts

@@ -24,12 +24,46 @@ export interface ParseProgress {
     directoriesScanned: number;
     /** Number of MSI/PNT files found */
     antennaFilesFound: number;
+    /** Number of files that failed to parse */
+    failedFiles: number;
+}
+/**
+ * Error information for failed file/folder parsing
+ */
+export interface ParseError {
+    /** Path to the file or folder that failed */
+    path: string;
+    /** Error message */
+    message: string;
+    /** Type of error */
+    type: 'file' | 'folder';
+}
+/**
+ * Result of folder parsing including errors
+ */
+export interface ParseFolderResult {
+    /** Successfully parsed antennas */
+    antennas: RawAntenna[];
+    /** Errors encountered during parsing */
+    errors: ParseError[];
+    /** Total files attempted */
+    totalFilesAttempted: number;
+    /** Total directories scanned */
+    totalDirectoriesScanned: number;
 }
 /**
  * Parse a folder of MSI files recursively
  * @param directoryHandle - File system directory handle
  * @param recursive - Whether to process subdirectories
  * @param onProgress - Optional callback for progress updates
- * @returns Array of parsed antennas
+ * @returns Array of parsed antennas (for backward compatibility)
  */
 export declare function parseFolder(directoryHandle: FileSystemDirectoryHandle, recursive?: boolean, onProgress?: (progress: ParseProgress) => void): Promise<RawAntenna[]>;
+/**
+ * Parse a folder of MSI files recursively with detailed error reporting
+ * @param directoryHandle - File system directory handle
+ * @param recursive - Whether to process subdirectories
+ * @param onProgress - Optional callback for progress updates
+ * @returns Object containing parsed antennas and any errors encountered
+ */
+export declare function parseFolderWithErrors(directoryHandle: FileSystemDirectoryHandle, recursive?: boolean, onProgress?: (progress: ParseProgress) => void): Promise<ParseFolderResult>;

package/dist/apps/antenna-tools/utils/msi-parser.js

@@ -174,55 +174,125 @@ export async function parseMSIFile(file) {
  * @param directoryHandle - File system directory handle
  * @param recursive - Whether to process subdirectories
  * @param onProgress - Optional callback for progress updates
- * @returns Array of parsed antennas
+ * @returns Array of parsed antennas (for backward compatibility)
  */
 export async function parseFolder(directoryHandle, recursive = true, onProgress) {
+    const result = await parseFolderWithErrors(directoryHandle, recursive, onProgress);
+    return result.antennas;
+}
+/**
+ * Parse a folder of MSI files recursively with detailed error reporting
+ * @param directoryHandle - File system directory handle
+ * @param recursive - Whether to process subdirectories
+ * @param onProgress - Optional callback for progress updates
+ * @returns Object containing parsed antennas and any errors encountered
+ */
+export async function parseFolderWithErrors(directoryHandle, recursive = true, onProgress) {
     const antennas = [];
+    const errors = [];
     let filesProcessed = 0;
     let directoriesScanned = 0;
+    let failedFiles = 0;
     // Process directory recursively
     async function processDirectory(dirHandle, path = '') {
         directoriesScanned++;
-        const iterator = dirHandle.values();
-        for await (const entry of iterator) {
-            if (entry.kind === 'file') {
-                try {
-                    // Type assertion to access getFile method
-                    const fileHandle = entry;
-                    const file = await fileHandle.getFile();
-                    const ext = file.name.split('.').pop()?.toLowerCase();
-                    if (ext === 'msi' || ext === 'pnt') {
-                        filesProcessed++;
-                        const currentPath = path ? `${path}/${file.name}` : file.name;
-                        // Report progress
-                        onProgress?.({
-                            currentFile: currentPath,
-                            filesProcessed,
-                            directoriesScanned,
-                            antennaFilesFound: antennas.length
-                        });
-                        try {
-                            const antenna = await parseMSIFile(file);
-                            // Add the path info to help identify where the file was found
-                            antenna.sourcePath = currentPath;
-                            antennas.push(antenna);
-                        }
-                        catch (error) {
-                            console.error(`Error parsing file ${currentPath}:`, error);
+        let iterator;
+        try {
+            iterator = dirHandle.values();
+        }
+        catch (error) {
+            const dirPath = path || dirHandle.name;
+            errors.push({
+                path: dirPath,
+                message: error instanceof Error ? error.message : 'Failed to read directory',
+                type: 'folder'
+            });
+            console.error(`Error reading directory ${dirPath}:`, error);
+            return; // Skip this directory but continue with others
+        }
+        try {
+            for await (const entry of iterator) {
+                if (entry.kind === 'file') {
+                    try {
+                        // Type assertion to access getFile method
+                        const fileHandle = entry;
+                        const file = await fileHandle.getFile();
+                        const ext = file.name.split('.').pop()?.toLowerCase();
+                        if (ext === 'msi' || ext === 'pnt') {
+                            filesProcessed++;
+                            const currentPath = path ? `${path}/${file.name}` : file.name;
+                            // Report progress
+                            onProgress?.({
+                                currentFile: currentPath,
+                                filesProcessed,
+                                directoriesScanned,
+                                antennaFilesFound: antennas.length,
+                                failedFiles
+                            });
+                            try {
+                                const antenna = await parseMSIFile(file);
+                                // Add the path info to help identify where the file was found
+                                antenna.sourcePath = currentPath;
+                                antennas.push(antenna);
+                            }
+                            catch (parseError) {
+                                failedFiles++;
+                                errors.push({
+                                    path: currentPath,
+                                    message: parseError instanceof Error ? parseError.message : 'Failed to parse file',
+                                    type: 'file'
+                                });
+                                console.error(`Error parsing file ${currentPath}:`, parseError);
+                                // Continue with next file
+                            }
                         }
                     }
+                    catch (fileError) {
+                        const filePath = path ? `${path}/${entry.name}` : entry.name;
+                        failedFiles++;
+                        errors.push({
+                            path: filePath,
+                            message: fileError instanceof Error ? fileError.message : 'Failed to access file',
+                            type: 'file'
+                        });
+                        console.error(`Error accessing file ${filePath}:`, fileError);
+                        // Continue with next file
+                    }
                 }
-                catch (error) {
-                    console.error('Error accessing file:', error);
+                else if (entry.kind === 'directory' && recursive) {
+                    // Process subdirectory if recursive flag is true
+                    const subDirPath = path ? `${path}/${entry.name}` : entry.name;
+                    try {
+                        await processDirectory(entry, subDirPath);
+                    }
+                    catch (subDirError) {
+                        errors.push({
+                            path: subDirPath,
+                            message: subDirError instanceof Error ? subDirError.message : 'Failed to process subdirectory',
+                            type: 'folder'
+                        });
+                        console.error(`Error processing subdirectory ${subDirPath}:`, subDirError);
+                        // Continue with next entry
+                    }
                 }
             }
-            else if (entry.kind === 'directory' && recursive) {
-                // Process subdirectory if recursive flag is true
-                const subDirPath = path ? `${path}/${entry.name}` : entry.name;
-                await processDirectory(entry, subDirPath);
-            }
+        }
+        catch (iterError) {
+            const dirPath = path || dirHandle.name;
+            errors.push({
+                path: dirPath,
+                message: iterError instanceof Error ? iterError.message : 'Error iterating directory contents',
+                type: 'folder'
+            });
+            console.error(`Error iterating directory ${dirPath}:`, iterError);
+            // Continue - the directory iteration failed but we can still return what we have
         }
     }
     await processDirectory(directoryHandle);
-    return antennas;
+    return {
+        antennas,
+        errors,
+        totalFilesAttempted: filesProcessed,
+        totalDirectoriesScanned: directoriesScanned
+    };
 }

package/dist/core/Auth/LoginForm.svelte

@@ -0,0 +1,397 @@
+<script lang="ts">
+	import type { AuthState } from './auth.svelte.js';
+
+	interface Props {
+		/** Auth state instance */
+		auth: AuthState;
+		/** Title for login form */
+		title?: string;
+		/** Subtitle/description */
+		subtitle?: string;
+		/** Logo URL (optional) */
+		logo?: string;
+		/** Callback on successful login */
+		onLogin?: () => void;
+	}
+
+	let {
+		auth,
+		title = 'Welcome',
+		subtitle = 'Sign in to access your tools',
+		logo,
+		onLogin
+	}: Props = $props();
+
+	// Form state
+	let username = $state('');
+	let password = $state('');
+	let agreedToMonitoring = $state(false);
+	let showPassword = $state(false);
+
+	// Form validation
+	const isFormValid = $derived(
+		username.trim().length > 0 && 
+		password.length > 0 && 
+		agreedToMonitoring
+	);
+
+	async function handleSubmit(e: SubmitEvent) {
+		e.preventDefault();
+		
+		if (!isFormValid) return;
+
+		const success = await auth.login(username.trim(), password, agreedToMonitoring);
+		
+		if (success) {
+			username = '';
+			password = '';
+			agreedToMonitoring = false;
+			onLogin?.();
+		}
+	}
+
+	function togglePassword() {
+		showPassword = !showPassword;
+	}
+</script>
+
+<div class="login-page">
+	<div class="login-card">
+		<!-- Header -->
+		<div class="login-header">
+			{#if logo}
+				<img src={logo} alt="Logo" class="login-logo" />
+			{:else}
+				<div class="login-icon">
+					<i class="bi bi-broadcast-pin"></i>
+				</div>
+			{/if}
+			<h1>{title}</h1>
+			<p>{subtitle}</p>
+		</div>
+
+		<!-- Error -->
+		{#if auth.error}
+			<div class="login-error">
+				<i class="bi bi-exclamation-circle"></i>
+				<span>{auth.error}</span>
+				<button type="button" onclick={() => auth.clearError()} aria-label="Dismiss error">
+					<i class="bi bi-x"></i>
+				</button>
+			</div>
+		{/if}
+
+		<!-- Form -->
+		<form onsubmit={handleSubmit} class="login-form">
+			<div class="form-field">
+				<label for="username">Username</label>
+				<div class="input-wrapper">
+					<i class="bi bi-person"></i>
+					<input
+						type="text"
+						id="username"
+						bind:value={username}
+						placeholder="Enter username"
+						autocomplete="username"
+						disabled={auth.isLoading}
+					/>
+				</div>
+			</div>
+
+			<div class="form-field">
+				<label for="password">Password</label>
+				<div class="input-wrapper">
+					<i class="bi bi-lock"></i>
+					<input
+						type={showPassword ? 'text' : 'password'}
+						id="password"
+						bind:value={password}
+						placeholder="Enter password"
+						autocomplete="current-password"
+						disabled={auth.isLoading}
+					/>
+					<button
+						type="button"
+						class="toggle-password"
+						onclick={togglePassword}
+						tabindex={-1}
+						aria-label={showPassword ? 'Hide password' : 'Show password'}
+					>
+						<i class="bi {showPassword ? 'bi-eye-slash' : 'bi-eye'}"></i>
+					</button>
+				</div>
+			</div>
+
+			<label class="checkbox-field">
+				<input
+					type="checkbox"
+					bind:checked={agreedToMonitoring}
+					disabled={auth.isLoading}
+				/>
+				<span class="checkmark"></span>
+				<span class="checkbox-text">
+					I agree to activity monitoring for security purposes
+				</span>
+			</label>
+
+			<button
+				type="submit"
+				class="login-button"
+				disabled={!isFormValid || auth.isLoading}
+			>
+				{#if auth.isLoading}
+					<span class="spinner"></span>
+					Signing in...
+				{:else}
+					Sign In
+					<i class="bi bi-arrow-right"></i>
+				{/if}
+			</button>
+		</form>
+
+		<div class="login-footer">
+			<i class="bi bi-shield-check"></i>
+			LDAP Authentication
+		</div>
+	</div>
+</div>
+
+<style>
+	.login-page {
+		min-height: 100vh;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		padding: 1.5rem;
+		background: linear-gradient(135deg, #0f172a 0%, #1e293b 100%);
+	}
+
+	.login-card {
+		width: 100%;
+		max-width: 380px;
+		background: #fff;
+		border-radius: 16px;
+		box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.4);
+		overflow: hidden;
+	}
+
+	.login-header {
+		text-align: center;
+		padding: 2.5rem 2rem 1.5rem;
+		background: linear-gradient(135deg, #3b82f6 0%, #1d4ed8 100%);
+		color: #fff;
+	}
+
+	.login-logo {
+		height: 48px;
+		margin-bottom: 1rem;
+	}
+
+	.login-icon {
+		font-size: 2.5rem;
+		margin-bottom: 0.75rem;
+	}
+
+	.login-header h1 {
+		font-size: 1.5rem;
+		font-weight: 600;
+		margin: 0 0 0.25rem;
+	}
+
+	.login-header p {
+		font-size: 0.875rem;
+		opacity: 0.85;
+		margin: 0;
+	}
+
+	.login-error {
+		display: flex;
+		align-items: center;
+		gap: 0.5rem;
+		margin: 1rem 1.5rem 0;
+		padding: 0.75rem 1rem;
+		background: #fef2f2;
+		border: 1px solid #fecaca;
+		border-radius: 8px;
+		color: #dc2626;
+		font-size: 0.875rem;
+	}
+
+	.login-error button {
+		margin-left: auto;
+		background: none;
+		border: none;
+		color: inherit;
+		cursor: pointer;
+		padding: 0;
+		font-size: 1.25rem;
+		line-height: 1;
+	}
+
+	.login-form {
+		padding: 1.5rem 2rem 2rem;
+	}
+
+	.form-field {
+		margin-bottom: 1.25rem;
+	}
+
+	.form-field label {
+		display: block;
+		font-size: 0.8125rem;
+		font-weight: 500;
+		color: #374151;
+		margin-bottom: 0.5rem;
+	}
+
+	.input-wrapper {
+		position: relative;
+		display: flex;
+		align-items: center;
+	}
+
+	.input-wrapper > i:first-child {
+		position: absolute;
+		left: 0.875rem;
+		color: #9ca3af;
+		font-size: 1rem;
+	}
+
+	.input-wrapper input {
+		width: 100%;
+		padding: 0.75rem 0.875rem 0.75rem 2.5rem;
+		border: 1px solid #e5e7eb;
+		border-radius: 8px;
+		font-size: 0.9375rem;
+		transition: border-color 0.15s, box-shadow 0.15s;
+	}
+
+	.input-wrapper input:focus {
+		outline: none;
+		border-color: #3b82f6;
+		box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.15);
+	}
+
+	.input-wrapper input:disabled {
+		background: #f9fafb;
+		cursor: not-allowed;
+	}
+
+	.toggle-password {
+		position: absolute;
+		right: 0.5rem;
+		background: none;
+		border: none;
+		color: #9ca3af;
+		cursor: pointer;
+		padding: 0.5rem;
+		font-size: 1rem;
+	}
+
+	.toggle-password:hover {
+		color: #6b7280;
+	}
+
+	.checkbox-field {
+		display: flex;
+		align-items: flex-start;
+		gap: 0.625rem;
+		cursor: pointer;
+		margin-bottom: 1.5rem;
+	}
+
+	.checkbox-field input {
+		position: absolute;
+		opacity: 0;
+		pointer-events: none;
+	}
+
+	.checkmark {
+		flex-shrink: 0;
+		width: 18px;
+		height: 18px;
+		border: 2px solid #d1d5db;
+		border-radius: 4px;
+		transition: all 0.15s;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.checkbox-field input:checked + .checkmark {
+		background: #3b82f6;
+		border-color: #3b82f6;
+	}
+
+	.checkbox-field input:checked + .checkmark::after {
+		content: '';
+		width: 5px;
+		height: 9px;
+		border: solid #fff;
+		border-width: 0 2px 2px 0;
+		transform: rotate(45deg);
+		margin-bottom: 2px;
+	}
+
+	.checkbox-text {
+		font-size: 0.8125rem;
+		color: #4b5563;
+		line-height: 1.4;
+	}
+
+	.login-button {
+		width: 100%;
+		padding: 0.875rem 1.5rem;
+		background: linear-gradient(135deg, #3b82f6 0%, #1d4ed8 100%);
+		color: #fff;
+		border: none;
+		border-radius: 8px;
+		font-size: 0.9375rem;
+		font-weight: 500;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		gap: 0.5rem;
+		transition: opacity 0.15s, transform 0.15s;
+	}
+
+	.login-button:hover:not(:disabled) {
+		opacity: 0.9;
+	}
+
+	.login-button:active:not(:disabled) {
+		transform: scale(0.98);
+	}
+
+	.login-button:disabled {
+		opacity: 0.5;
+		cursor: not-allowed;
+	}
+
+	.spinner {
+		width: 16px;
+		height: 16px;
+		border: 2px solid rgba(255, 255, 255, 0.3);
+		border-top-color: #fff;
+		border-radius: 50%;
+		animation: spin 0.8s linear infinite;
+	}
+
+	@keyframes spin {
+		to { transform: rotate(360deg); }
+	}
+
+	.login-footer {
+		text-align: center;
+		padding: 1rem;
+		background: #f8fafc;
+		border-top: 1px solid #e5e7eb;
+		font-size: 0.75rem;
+		color: #64748b;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		gap: 0.375rem;
+	}
+</style>

package/dist/core/Auth/LoginForm.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { AuthState } from './auth.svelte.js';
+interface Props {
+    /** Auth state instance */
+    auth: AuthState;
+    /** Title for login form */
+    title?: string;
+    /** Subtitle/description */
+    subtitle?: string;
+    /** Logo URL (optional) */
+    logo?: string;
+    /** Callback on successful login */
+    onLogin?: () => void;
+}
+declare const LoginForm: import("svelte").Component<Props, {}, "">;
+type LoginForm = ReturnType<typeof LoginForm>;
+export default LoginForm;

package/dist/core/Auth/auth.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { UserSession, User, FeatureAccess, AuthConfig } from './types.js';
+/**
+ * Create auth state store with Svelte 5 runes
+ * This must be called within a component context or .svelte.ts file
+ */
+export declare function createAuthState(config?: Partial<AuthConfig>): {
+    readonly session: UserSession | null;
+    readonly isLoading: boolean;
+    readonly error: string | null;
+    readonly initialized: boolean;
+    readonly isAuthenticated: boolean;
+    readonly user: User | null;
+    readonly permissions: FeatureAccess[];
+    readonly token: string | null;
+    login: (username: string, password: string, agreedToMonitoring: boolean) => Promise<boolean>;
+    loginDev: (devUser: User, devPermissions: FeatureAccess[]) => void;
+    logout: () => Promise<void>;
+    hasPermission: (featureId: string, level?: "view" | "edit" | "admin") => boolean;
+    canAccessRoute: (route: string, requiredPermission?: string) => boolean;
+    clearError: () => void;
+};
+export type AuthState = ReturnType<typeof createAuthState>;