@mhmo91/schmancy 0.10.41 → 0.10.43

package/src/area/area.service.ts

@@ -16,7 +16,7 @@ import {
 	Subscription,
 	tap,
 	timeout,
-	zip
+	zip,
 } from 'rxjs'
 import { SchmancyTeleportation } from '../teleport'
 import { ActiveRoute, AreaSubscription, RouteAction } from './router.types'
@@ -45,7 +45,7 @@ class AreaService implements AreaSubscription {
 	public request = new ReplaySubject<RouteAction>(1)
 	public current = new Map<string, ActiveRoute>()
 	public $current = new ReplaySubject<Map<string, ActiveRoute>>(1)
-	
+
 	// Create a dictionary of ReplaySubjects for area-specific subscriptions
 	private get areaSubjects(): Map<string, ReplaySubject<ActiveRoute>> {
 		let subjects = areaSubjectsCache.get(this)
@@ -55,7 +55,7 @@ class AreaService implements AreaSubscription {
 		}
 		return subjects
 	}
-	
+
 	public enableHistoryMode = true
 	private findingMortiesEvent = new CustomEvent<FINDING_MORTIES_EVENT['detail']>(FINDING_MORTIES)
 	private disposed = false
@@ -64,11 +64,11 @@ class AreaService implements AreaSubscription {
 
 	constructor() {
 		this.$current.next(this.current)
-		
+
 		// Subscribe to current changes to update area-specific subjects
 		this.$current.subscribe(currentAreas => {
 			if (this.disposed) return
-			
+
 			// For each area in the current map
 			currentAreas.forEach((route, areaName) => {
 				// Get or create a subject for this area
@@ -111,11 +111,11 @@ class AreaService implements AreaSubscription {
 	 */
 	private getOrCreateAreaSubject(areaName: string): ReplaySubject<ActiveRoute> {
 		let subject = this.areaSubjects.get(areaName)
-		
+
 		if (!subject || subject.closed) {
 			subject = new ReplaySubject<ActiveRoute>(1)
 			this.areaSubjects.set(areaName, subject)
-			
+
 			// If the area already exists in current, emit it immediately
 			const currentRoute = this.current.get(areaName)
 			if (currentRoute) {
@@ -124,11 +124,11 @@ class AreaService implements AreaSubscription {
 					// Ensure state, params and props are initialized if undefined
 					state: currentRoute.state || {},
 					params: currentRoute.params || {},
-					props: currentRoute.props || {}
+					props: currentRoute.props || {},
 				})
 			}
 		}
-		
+
 		return subject
 	}
 
@@ -143,29 +143,28 @@ class AreaService implements AreaSubscription {
 		const areaSubject = this.getOrCreateAreaSubject(areaName)
 		const observable = areaSubject.asObservable().pipe(
 			// Add distinct to prevent duplicate emissions - includes state, params, and props
-			distinctUntilChanged((a, b) =>
-				a.component === b.component &&
-				JSON.stringify(a.state) === JSON.stringify(b.state) &&
-				JSON.stringify(a.params) === JSON.stringify(b.params) &&
-				JSON.stringify(a.props) === JSON.stringify(b.props)
+			distinctUntilChanged(
+				(a, b) =>
+					a.component === b.component &&
+					JSON.stringify(a.state) === JSON.stringify(b.state) &&
+					JSON.stringify(a.params) === JSON.stringify(b.params) &&
+					JSON.stringify(a.props) === JSON.stringify(b.props),
 			),
 			// Share the subscription
-			shareReplay(1)
+			shareReplay(1),
 		)
 
 		return skipCurrent ? observable.pipe(skip(1)) : observable
 	}
-	
+
 	/**
 	 * Subscribe to all areas
 	 */
 	all(skipCurrent = false): Observable<Map<string, ActiveRoute>> {
-		const observable = this.$current.asObservable().pipe(
-			shareReplay(1)
-		)
+		const observable = this.$current.asObservable().pipe(shareReplay(1))
 		return skipCurrent ? observable.pipe(skip(1)) : observable
 	}
-	
+
 	/**
 	 * Get state from an area with type safety
 	 */
@@ -173,21 +172,19 @@ class AreaService implements AreaSubscription {
 		if (!areaName) {
 			throw new Error('Area name is required')
 		}
-		
+
 		return this.on(areaName).pipe(
 			map(route => route.state),
-			filter((state): state is NonNullable<Record<string, unknown>> => 
-				state !== undefined && state !== null
-			),
+			filter((state): state is NonNullable<Record<string, unknown>> => state !== undefined && state !== null),
 			distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)),
 			map(state => state as T),
 			catchError(err => {
 				console.error(`Error getting state for area "${areaName}":`, err)
 				return EMPTY
-			})
+			}),
 		)
 	}
-	
+
 	/**
 	 * Get params from an area with type safety
 	 * Emits current value immediately on subscription via startWith
@@ -216,10 +213,10 @@ class AreaService implements AreaSubscription {
 			catchError(err => {
 				console.error(`Error getting params for area "${areaName}":`, err)
 				return EMPTY
-			})
+			}),
 		)
 	}
-	
+
 	/**
 	 * Get a specific param from an area with null safety
 	 */
@@ -227,7 +224,7 @@ class AreaService implements AreaSubscription {
 		if (!areaName || !key) {
 			throw new Error('Area name and key are required')
 		}
-		
+
 		return this.params<Record<string, unknown>>(areaName).pipe(
 			map(params => params[key]),
 			filter((value): value is NonNullable<unknown> => value !== undefined),
@@ -236,10 +233,10 @@ class AreaService implements AreaSubscription {
 			catchError(err => {
 				console.error(`Error getting param "${key}" for area "${areaName}":`, err)
 				return EMPTY
-			})
+			}),
 		)
 	}
-	
+
 	/**
 	 * Get props from an area with type safety
 	 */
@@ -247,21 +244,19 @@ class AreaService implements AreaSubscription {
 		if (!areaName) {
 			throw new Error('Area name is required')
 		}
-		
+
 		return this.on(areaName).pipe(
 			map(route => route.props),
-			filter((props): props is NonNullable<Record<string, unknown>> => 
-				props !== undefined && props !== null
-			),
+			filter((props): props is NonNullable<Record<string, unknown>> => props !== undefined && props !== null),
 			distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)),
 			map(props => props as T),
 			catchError(err => {
 				console.error(`Error getting props for area "${areaName}":`, err)
 				return EMPTY
-			})
+			}),
 		)
 	}
-	
+
 	/**
 	 * Get a specific prop from an area with null safety
 	 */
@@ -269,7 +264,7 @@ class AreaService implements AreaSubscription {
 		if (!areaName || !key) {
 			throw new Error('Area name and key are required')
 		}
-		
+
 		return this.props<Record<string, unknown>>(areaName).pipe(
 			map(props => props[key]),
 			filter((value): value is NonNullable<unknown> => value !== undefined),
@@ -278,7 +273,7 @@ class AreaService implements AreaSubscription {
 			catchError(err => {
 				console.error(`Error getting prop "${key}" for area "${areaName}":`, err)
 				return EMPTY
-			})
+			}),
 		)
 	}
 
@@ -295,7 +290,7 @@ class AreaService implements AreaSubscription {
 		]).pipe(
 			map(([component]) => component),
 			timeout(1),
-			catchError(() => EMPTY)
+			catchError(() => EMPTY),
 		)
 	}
 
@@ -306,26 +301,26 @@ class AreaService implements AreaSubscription {
 		if (!r.area) {
 			throw new Error('Area is required for route action')
 		}
-		
+
 		// Prevent processing during popstate handling
 		if (this.isProcessingPopstate) {
 			return
 		}
-		
+
 		// Ensure state, params and props are initialized
 		const routeAction: RouteAction = {
 			...r,
 			state: r.state || {},
 			params: r.params || {},
 			props: r.props || {},
-			_source: 'programmatic' as NavigationSource
+			_source: 'programmatic' as NavigationSource,
 		}
-		
+
 		// Add to history if enabled
 		if (this.enableHistoryMode) {
 			routerHistory.next(routeAction)
 		}
-		
+
 		this.request.next(routeAction)
 		// Emit an area-specific event for those who want to listen directly to DOM events
 		this.dispatchAreaEvent(routeAction.area, routeAction)
@@ -341,9 +336,9 @@ class AreaService implements AreaSubscription {
 			state: routeAction.state || {},
 			params: routeAction.params || {},
 			props: routeAction.props || {},
-			_source: 'browser' as NavigationSource
+			_source: 'browser' as NavigationSource,
 		}
-		
+
 		this.isProcessingPopstate = true
 		this.request.next(enhancedRoute)
 		this.isProcessingPopstate = false
@@ -352,7 +347,13 @@ class AreaService implements AreaSubscription {
 	/**
 	 * Update browser history state (called by area components)
 	 */
-	updateBrowserHistory(areaName: string, route: ActiveRoute, historyStrategy?: string, clearQueryParams?: string[] | boolean | null, customPath?: string) {
+	updateBrowserHistory(
+		areaName: string,
+		route: ActiveRoute,
+		historyStrategy?: string,
+		clearQueryParams?: string[] | boolean | null,
+		customPath?: string,
+	) {
 		if (!this.enableHistoryMode) return
 
 		try {
@@ -363,7 +364,7 @@ class AreaService implements AreaSubscription {
 			// Update the specific area - only include non-empty state/params/props
 			const areaData: any = {
 				component: route.component,
-				area: route.area
+				area: route.area,
 			}
 
 			// Only include state if it has content
@@ -385,7 +386,7 @@ class AreaService implements AreaSubscription {
 
 			const newState = {
 				...currentState,
-				schmancyAreas
+				schmancyAreas,
 			}
 
 			// Create clean URL with optional custom path
@@ -398,7 +399,6 @@ class AreaService implements AreaSubscription {
 				history.pushState(newState, '', url)
 			}
 			// 'silent' strategy doesn't update browser history
-
 		} catch (error) {
 			console.error('Failed to update browser history:', error)
 		}
@@ -407,7 +407,11 @@ class AreaService implements AreaSubscription {
 	/**
 	 * Create a clean URL from area states
 	 */
-	private createCleanURL(areas: Record<string, ActiveRoute>, clearQueryParams?: string[] | boolean | null, customPath?: string): string {
+	private createCleanURL(
+		areas: Record<string, ActiveRoute>,
+		clearQueryParams?: string[] | boolean | null,
+		customPath?: string,
+	): string {
 		let basePath = '/'
 
 		// If custom path is provided, use it directly (completely replaces the path)
@@ -545,7 +549,7 @@ class AreaService implements AreaSubscription {
 		} catch (error) {
 			console.error('Failed to restore from browser state:', error)
 		}
-		
+
 		// Fallback to URL parsing (original behavior)
 		return this.parseStateFromURL()
 	}
@@ -556,37 +560,37 @@ class AreaService implements AreaSubscription {
 	private parseStateFromURL(): Record<string, ActiveRoute> {
 		const pathname = location.pathname.split('/').pop()
 		if (!pathname) return {}
-		
+
 		try {
 			const decoded = decodeURIComponent(pathname)
 			const parsed = JSON.parse(decoded)
-			
+
 			if (typeof parsed === 'object' && parsed !== null) {
 				return parsed
 			}
 		} catch {
 			// Ignore parse errors
 		}
-		
+
 		return {}
 	}
-	
+
 	/**
 	 * Dispatch a DOM event for a specific area change
 	 */
 	private dispatchAreaEvent(areaName: string, routeAction: RouteAction) {
 		const eventName = `schmancy-area-${areaName}-changed`
-		const event = new CustomEvent(eventName, { 
-			detail: { 
+		const event = new CustomEvent(eventName, {
+			detail: {
 				area: areaName,
 				component: routeAction.component,
 				state: routeAction.state,
 				params: routeAction.params,
 				props: routeAction.props,
-				historyStrategy: routeAction.historyStrategy
+				historyStrategy: routeAction.historyStrategy,
 			},
 			bubbles: true,
-			composed: true
+			composed: true,
 		})
 		window.dispatchEvent(event)
 	}
@@ -609,7 +613,7 @@ class AreaService implements AreaSubscription {
 				state: {},
 				area: name,
 				params: {},
-				props: {}
+				props: {},
 			})
 		}
 
@@ -622,7 +626,7 @@ class AreaService implements AreaSubscription {
 			params: {},
 			props: {},
 			historyStrategy: 'silent' as any,
-			_source: 'programmatic' as NavigationSource
+			_source: 'programmatic' as NavigationSource,
 		})
 
 		// Remove from current map
@@ -638,7 +642,7 @@ class AreaService implements AreaSubscription {
 
 				const newState = {
 					...currentState,
-					schmancyAreas
+					schmancyAreas,
 				}
 
 				const url = this.createCleanURL(schmancyAreas)
@@ -648,7 +652,7 @@ class AreaService implements AreaSubscription {
 			}
 		}
 	}
-	
+
 	/**
 	 * Clear all areas
 	 */
@@ -667,7 +671,7 @@ class AreaService implements AreaSubscription {
 			history.replaceState({ schmancyAreas: {} }, '', url)
 		}
 	}
-	
+
 	/**
 	 * Dispose of the service and clean up resources
 	 */
@@ -694,7 +698,7 @@ class AreaService implements AreaSubscription {
 		this.current.clear()
 		areaSubjectsCache.delete(this)
 	}
-	
+
 	/**
 	 * Get singleton instance
 	 */
@@ -718,25 +722,25 @@ class AreaService implements AreaSubscription {
 		} catch {
 			// Fallback to URL parsing
 		}
-		
+
 		// Fallback to URL parsing (original behavior)
 		return this.parseStateFromURL()
 	}
-	
+
 	/**
 	 * Check if an area exists in current state
 	 */
 	hasArea(areaName: string): boolean {
 		return this.current.has(areaName)
 	}
-	
+
 	/**
 	 * Get all active area names
 	 */
 	getActiveAreas(): string[] {
 		return Array.from(this.current.keys())
 	}
-	
+
 	/**
 	 * Get route for a specific area synchronously
 	 */
@@ -757,4 +761,4 @@ class AreaService implements AreaSubscription {
  * @method current$(areaName) - Observable of the active route state for an area.
  */
 export const area = AreaService.getInstance()
-export default area
+export default area

package/src/area/index.ts

@@ -1,7 +1,7 @@
-export * from './area.component';
-export * from './area.service';
-export * from './ecrypt';
-export * from './lazy';
-export * from './route.component';
-export * from './router.types';
-export * from './utils';
+export * from './area.component'
+export * from './area.service'
+export * from './ecrypt'
+export * from './lazy'
+export * from './route.component'
+export * from './router.types'
+export * from './utils'

package/src/area/lazy.ts

@@ -10,8 +10,8 @@ type CustomElementConstructor = typeof HTMLElement
  * LazyComponent interface with preload capability
  */
 export interface LazyComponent<T extends CustomElementConstructor = CustomElementConstructor> {
-  (): Promise<{ default: T }>
-  preload(): Promise<void>
+	(): Promise<{ default: T }>
+	preload(): Promise<void>
 }
 
 // Per-component load cache. Kept off the public LazyComponent surface so the
@@ -39,49 +39,46 @@ const moduleCache = new WeakMap<object, { default: CustomElementConstructor }>()
  * @param loader - Dynamic import function that returns a module with default export
  * @returns LazyComponent function compatible with area.push()
  */
-export function lazy<T extends CustomElementConstructor>(
-  loader: () => Promise<{ default: T }>
-): LazyComponent<T> {
+export function lazy<T extends CustomElementConstructor>(loader: () => Promise<{ default: T }>): LazyComponent<T> {
+	// Create the lazy component function
+	const lazyComponent = function (): Promise<{ default: T }> {
+		// Return cached promise if already loading/loaded
+		const cachedPromise = promiseCache.get(lazyComponent)
+		if (cachedPromise) {
+			return cachedPromise as Promise<{ default: T }>
+		}
 
-  // Create the lazy component function
-  const lazyComponent = function(): Promise<{ default: T }> {
-    // Return cached promise if already loading/loaded
-    const cachedPromise = promiseCache.get(lazyComponent)
-    if (cachedPromise) {
-      return cachedPromise as Promise<{ default: T }>
-    }
+		// Return cached module if already loaded
+		const cachedModule = moduleCache.get(lazyComponent)
+		if (cachedModule) {
+			return Promise.resolve(cachedModule as { default: T })
+		}
 
-    // Return cached module if already loaded
-    const cachedModule = moduleCache.get(lazyComponent)
-    if (cachedModule) {
-      return Promise.resolve(cachedModule as { default: T })
-    }
+		// Start loading and cache the promise
+		const promise = loader()
+			.then(module => {
+				// Cache the loaded module
+				moduleCache.set(lazyComponent, module)
+				return module
+			})
+			.catch(error => {
+				// Clear promise on error to allow retry
+				promiseCache.delete(lazyComponent)
+				throw error
+			})
+		promiseCache.set(lazyComponent, promise)
 
-    // Start loading and cache the promise
-    const promise = loader()
-      .then(module => {
-        // Cache the loaded module
-        moduleCache.set(lazyComponent, module)
-        return module
-      })
-      .catch(error => {
-        // Clear promise on error to allow retry
-        promiseCache.delete(lazyComponent)
-        throw error
-      })
-    promiseCache.set(lazyComponent, promise)
+		return promise
+	} as LazyComponent<T>
 
-    return promise
-  } as LazyComponent<T>
+	// Add preload method for manual preloading
+	lazyComponent.preload = async function (): Promise<void> {
+		try {
+			await lazyComponent()
+		} catch (error) {
+			console.error('Failed to preload component:', error)
+		}
+	}
 
-  // Add preload method for manual preloading
-  lazyComponent.preload = async function(): Promise<void> {
-    try {
-      await lazyComponent()
-    } catch (error) {
-      console.error('Failed to preload component:', error)
-    }
-  }
-
-  return lazyComponent
+	return lazyComponent
 }