{"version":3,"file":"layout-engine.mjs","sources":["../../../../src/lib/layouts/adaptive/layout-engine.ts"],"sourcesContent":["/**\n * @fileoverview Content-Aware Layout Engine\n *\n * This module implements a sophisticated layout engine that automatically selects\n * and computes optimal layouts based on content analysis. It uses ResizeObserver\n * for responsive behavior without traditional breakpoints, preferring content-driven\n * layout decisions.\n *\n * Key Features:\n * - Content-aware layout mode selection\n * - Breakpoint-free responsive design\n * - Performance budget awareness\n * - Predictive layout pre-computation\n * - User preference learning\n *\n * @module layouts/adaptive/layout-engine\n * @version 1.0.0\n */\n\nimport type {\n AspectRatioDistribution,\n ContentAnalysis,\n ContentDensity,\n Dimensions,\n GridLayoutConfig,\n LayoutComputeRequest,\n LayoutComputeResult,\n LayoutConstraint,\n LayoutEngineConfig,\n LayoutEngineInterface,\n LayoutMode,\n LayoutRect,\n LayoutState,\n ListLayoutConfig,\n UserLayoutPreferences,\n} from './types';\nimport { DEFAULT_LAYOUT_ENGINE_CONFIG } from './types';\n\n// =============================================================================\n// CONSTANTS\n// =============================================================================\n\n/**\n * Golden ratio for aesthetically pleasing layouts.\n */\nconst PHI = 1.618033988749895;\n\n/**\n * Content density thresholds based on items per viewport area.\n */\nconst DENSITY_THRESHOLDS: Record = {\n minimal: 0.001,\n low: 0.005,\n medium: 0.02,\n high: 0.05,\n extreme: 0.1,\n} as const;\n\n/**\n * Size variance thresholds for layout mode selection.\n */\nconst VARIANCE_THRESHOLDS = {\n uniform: 0.1,\n moderate: 0.3,\n high: 0.5,\n} as const;\n\n/**\n * Minimum items required for meaningful analysis.\n */\nconst MIN_ITEMS_FOR_ANALYSIS = 2;\n\n// =============================================================================\n// HELPER FUNCTIONS\n// =============================================================================\n\n/**\n * Calculates the standard deviation of an array of numbers.\n */\nfunction calculateStandardDeviation(values: readonly number[]): number {\n if (values.length === 0) return 0;\n const mean = values.reduce((sum, val) => sum + val, 0) / values.length;\n const squaredDiffs = values.map((val) => Math.pow(val - mean, 2));\n const avgSquaredDiff = squaredDiffs.reduce((sum, val) => sum + val, 0) / values.length;\n return Math.sqrt(avgSquaredDiff);\n}\n\n/**\n * Calculates coefficient of variation (normalized standard deviation).\n */\nfunction calculateCoefficientOfVariation(values: readonly number[]): number {\n if (values.length === 0) return 0;\n const mean = values.reduce((sum, val) => sum + val, 0) / values.length;\n if (mean === 0) return 0;\n return calculateStandardDeviation(values) / mean;\n}\n\n/**\n * Classifies an aspect ratio into a category.\n */\nfunction classifyAspectRatio(ratio: number): keyof AspectRatioDistribution {\n if (ratio < 0.75) return 'portrait';\n if (ratio <= 1.33) return 'square';\n if (ratio <= 2) return 'landscape';\n return 'ultrawide';\n}\n\n/**\n * Determines if content is primarily image-based.\n */\nfunction isImageHeavyContent(element: HTMLElement): boolean {\n const images = element.querySelectorAll('img, picture, video, canvas, svg');\n const textLength = element.textContent?.length ?? 0;\n const imageCount = images.length;\n\n // Heuristic: more than 1 image per 200 chars of text indicates image-heavy content\n return imageCount > 0 && (textLength === 0 || imageCount / (textLength / 200) > 0.5);\n}\n\n/**\n * Determines if content is primarily text-based.\n */\nfunction isTextHeavyContent(element: HTMLElement): boolean {\n const textLength = element.textContent?.length ?? 0;\n const images = element.querySelectorAll('img, picture, video, canvas, svg');\n\n // Heuristic: more than 500 chars with few images indicates text-heavy content\n return textLength > 500 && images.length < textLength / 500;\n}\n\n/**\n * Generates a unique batch ID.\n */\n// function _generateBatchId(): string {\n// return `batch_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;\n// }\n\n// =============================================================================\n// LAYOUT ENGINE IMPLEMENTATION\n// =============================================================================\n\n/**\n * Content-aware layout engine that automatically selects and computes\n * optimal layouts based on content analysis.\n *\n * @example\n * ```typescript\n * const engine = createLayoutEngine({ contentAware: true });\n * const analysis = engine.analyze(containerElement);\n * const result = engine.compute({\n * containerId: 'my-container',\n * itemIds: ['item-1', 'item-2', 'item-3'],\n * containerDimensions: { width: 800, height: 600 }\n * });\n * ```\n */\nexport class LayoutEngine implements LayoutEngineInterface {\n private readonly _resizeObserver: ResizeObserver;\n private readonly _callbacks: Map void>;\n private readonly _elementCache: WeakMap;\n private readonly _userPreferences: UserLayoutPreferences;\n private _destroyed: boolean = false;\n\n /**\n * Creates a new LayoutEngine instance.\n *\n * @param config - Optional configuration overrides\n */\n constructor(config: Partial = {}) {\n this._config = { ...DEFAULT_LAYOUT_ENGINE_CONFIG, ...config };\n this._callbacks = new Map();\n this._elementCache = new WeakMap();\n this._userPreferences = this._initializeUserPreferences();\n\n // Create shared ResizeObserver with debouncing\n this._resizeObserver = new ResizeObserver(this._handleResize.bind(this));\n }\n\n private _config: LayoutEngineConfig;\n\n /**\n * Current engine configuration.\n */\n get config(): LayoutEngineConfig {\n return this._config;\n }\n\n /**\n * Updates the engine configuration.\n *\n * @param config - Partial configuration to merge\n */\n configure(config: Partial): void {\n this._assertNotDestroyed();\n this._config = { ...this._config, ...config };\n }\n\n /**\n * Analyzes container content to determine optimal layout characteristics.\n *\n * @param container - The container element to analyze\n * @returns Content analysis result\n */\n analyze(container: HTMLElement): ContentAnalysis {\n this._assertNotDestroyed();\n\n // Check cache first\n const cached = this._elementCache.get(container);\n if (cached && this._config.predictiveLayout) {\n return cached;\n }\n\n const children = Array.from(container.children) as HTMLElement[];\n const itemCount = children.length;\n\n if (itemCount < MIN_ITEMS_FOR_ANALYSIS) {\n return this._createMinimalAnalysis(container, itemCount);\n }\n\n // Gather dimensions\n const dimensions = children.map((child) => {\n const rect = child.getBoundingClientRect();\n return { width: rect.width, height: rect.height };\n });\n\n // Calculate statistics\n const widths = dimensions.map((d) => d.width);\n const heights = dimensions.map((d) => d.height);\n const areas = dimensions.map((d) => d.width * d.height);\n\n const avgWidth = widths.reduce((sum, w) => sum + w, 0) / itemCount;\n const avgHeight = heights.reduce((sum, h) => sum + h, 0) / itemCount;\n const avgArea = areas.reduce((sum, a) => sum + a, 0) / itemCount;\n\n // Calculate variance\n const widthVariance = calculateCoefficientOfVariation(widths);\n const heightVariance = calculateCoefficientOfVariation(heights);\n const sizeVariance = (widthVariance + heightVariance) / 2;\n\n // Calculate density\n const containerRect = container.getBoundingClientRect();\n const containerArea = containerRect.width * containerRect.height;\n const totalItemArea = avgArea * itemCount;\n const densityRatio = containerArea > 0 ? totalItemArea / containerArea : 0;\n const density = this._classifyDensity(densityRatio);\n\n // Analyze aspect ratios\n const aspectRatios = dimensions.map((d) => (d.height > 0 ? d.width / d.height : 1));\n const aspectRatioDistribution = this._calculateAspectRatioDistribution(aspectRatios);\n\n // Content type detection\n const imageHeavy = isImageHeavyContent(container);\n const textHeavy = isTextHeavyContent(container);\n\n // Determine recommended mode\n const recommendedMode = this._recommendLayoutMode(\n density,\n sizeVariance,\n aspectRatioDistribution,\n imageHeavy,\n textHeavy\n );\n\n const analysis: ContentAnalysis = {\n itemCount,\n averageItemSize: { width: avgWidth, height: avgHeight },\n sizeVariance,\n density,\n recommendedMode,\n confidence: this._calculateConfidence(sizeVariance, itemCount),\n isImageHeavy: imageHeavy,\n isTextHeavy: textHeavy,\n aspectRatioDistribution,\n };\n\n // Cache the result\n this._elementCache.set(container, analysis);\n\n return analysis;\n }\n\n /**\n * Computes the complete layout for a container and its items.\n *\n * @param request - Layout computation request\n * @returns Layout computation result\n */\n compute(request: LayoutComputeRequest): LayoutComputeResult {\n this._assertNotDestroyed();\n\n const startTime = performance.now();\n\n // Get or create analysis\n const containerElement = document.getElementById(request.containerId);\n const analysis = containerElement\n ? this.analyze(containerElement)\n : this._createMinimalAnalysis(null, request.itemIds.length);\n\n // Determine layout mode\n const mode = request.forcedMode ?? analysis.recommendedMode;\n\n // Compute item positions based on mode\n const itemRects = this._computeItemRects(\n request.itemIds,\n request.containerDimensions,\n mode,\n analysis\n );\n\n // Get mode-specific configuration\n const gridConfig = mode === 'grid' ? this._computeGridConfig(request.containerDimensions, analysis) : undefined;\n const listConfig = mode === 'list' ? this._computeListConfig(request.containerDimensions, analysis) : undefined;\n\n const computeTimeMs = performance.now() - startTime;\n // this.__lastComputeTime = computeTimeMs;\n\n const state: LayoutState = {\n mode,\n containerDimensions: request.containerDimensions,\n itemRects,\n gridConfig,\n listConfig,\n timestamp: Date.now(),\n isTransitioning: false,\n };\n\n return {\n state,\n analysis,\n computeTimeMs,\n budgetExceeded: computeTimeMs > this._config.performanceBudgetMs,\n predictedCLS: this._predictCLS(state, request.animationContext),\n };\n }\n\n /**\n * Selects the optimal layout mode based on content analysis and constraints.\n *\n * @param analysis - Content analysis result\n * @param constraints - Active layout constraints\n * @returns Selected layout mode\n */\n selectMode(analysis: ContentAnalysis, constraints: readonly LayoutConstraint[]): LayoutMode {\n this._assertNotDestroyed();\n\n // Check for forced mode in constraints\n const forcedConstraint = constraints.find(\n (c) => c.type === 'containment' && c.priority === 'required'\n );\n if (forcedConstraint) {\n // Check user preferences first if learning is enabled\n if (this._config.learnPreferences) {\n const preferredMode = this._userPreferences.modePreferences.get(analysis.density);\n if (preferredMode) {\n return preferredMode;\n }\n }\n }\n\n // Consider accessibility mode\n if (this._config.accessibilityMode && analysis.density !== 'minimal') {\n return analysis.density === 'high' || analysis.density === 'extreme' ? 'list' : 'expanded';\n }\n\n return analysis.recommendedMode;\n }\n\n /**\n * Observes a container element for size changes.\n *\n * @param container - Element to observe\n * @param callback - Callback for resize events\n * @returns Cleanup function\n */\n observe(container: HTMLElement, callback: (entry: ResizeObserverEntry) => void): () => void {\n this._assertNotDestroyed();\n\n this._callbacks.set(container, callback);\n this._resizeObserver.observe(container);\n\n return () => {\n this._callbacks.delete(container);\n this._resizeObserver.unobserve(container);\n };\n }\n\n /**\n * Cleans up all resources used by the engine.\n */\n destroy(): void {\n if (this._destroyed) return;\n\n this._resizeObserver.disconnect();\n this._callbacks.clear();\n this._destroyed = true;\n }\n\n // ===========================================================================\n // PRIVATE METHODS\n // ===========================================================================\n\n /**\n * Handles ResizeObserver callbacks with debouncing.\n */\n private _handleResize(entries: ResizeObserverEntry[]): void {\n for (const entry of entries) {\n const callback = this._callbacks.get(entry.target as HTMLElement);\n if (callback) {\n // Invalidate cache on resize\n this._elementCache.delete(entry.target as HTMLElement);\n callback(entry);\n }\n }\n }\n\n /**\n * Creates a minimal analysis for containers with few items.\n */\n private _createMinimalAnalysis(_container: HTMLElement | null, itemCount: number): ContentAnalysis {\n return {\n itemCount,\n averageItemSize: { width: 200, height: 150 },\n sizeVariance: 0,\n density: 'minimal',\n recommendedMode: this._config.defaultMode,\n confidence: 0.5,\n isImageHeavy: false,\n isTextHeavy: false,\n aspectRatioDistribution: { portrait: 0, square: 1, landscape: 0, ultrawide: 0 },\n };\n }\n\n /**\n * Classifies density ratio into a ContentDensity category.\n */\n private _classifyDensity(densityRatio: number): ContentDensity {\n if (densityRatio >= DENSITY_THRESHOLDS.extreme) return 'extreme';\n if (densityRatio >= DENSITY_THRESHOLDS.high) return 'high';\n if (densityRatio >= DENSITY_THRESHOLDS.medium) return 'medium';\n if (densityRatio >= DENSITY_THRESHOLDS.low) return 'low';\n return 'minimal';\n }\n\n /**\n * Calculates aspect ratio distribution from a list of ratios.\n */\n private _calculateAspectRatioDistribution(ratios: readonly number[]): AspectRatioDistribution {\n const distribution = { portrait: 0, square: 0, landscape: 0, ultrawide: 0 };\n const total = ratios.length;\n\n if (total === 0) return distribution;\n\n for (const ratio of ratios) {\n const category = classifyAspectRatio(ratio);\n distribution[category]++;\n }\n\n // Normalize to percentages\n return {\n portrait: distribution.portrait / total,\n square: distribution.square / total,\n landscape: distribution.landscape / total,\n ultrawide: distribution.ultrawide / total,\n };\n }\n\n /**\n * Recommends a layout mode based on content characteristics.\n */\n private _recommendLayoutMode(\n density: ContentDensity,\n sizeVariance: number,\n aspectRatios: AspectRatioDistribution,\n imageHeavy: boolean,\n textHeavy: boolean\n ): LayoutMode {\n // Text-heavy content prefers list layout\n if (textHeavy) {\n return density === 'high' || density === 'extreme' ? 'compact' : 'list';\n }\n\n // Image-heavy content with uniform sizes prefers grid\n if (imageHeavy && sizeVariance < VARIANCE_THRESHOLDS.uniform) {\n return 'grid';\n }\n\n // High variance suggests expanded layout to show content properly\n if (sizeVariance > VARIANCE_THRESHOLDS.high) {\n return 'expanded';\n }\n\n // Portrait-heavy content might work better in list\n if (aspectRatios.portrait > 0.6) {\n return 'list';\n }\n\n // Landscape/ultrawide content works well in grid\n if (aspectRatios.landscape + aspectRatios.ultrawide > 0.6) {\n return 'grid';\n }\n\n // Default based on density\n switch (density) {\n case 'extreme':\n case 'high':\n return 'compact';\n case 'medium':\n return 'grid';\n case 'low':\n case 'minimal':\n return 'expanded';\n }\n }\n\n /**\n * Calculates confidence score for the recommendation.\n */\n private _calculateConfidence(sizeVariance: number, itemCount: number): number {\n // Base confidence from item count (more items = more reliable analysis)\n const countConfidence = Math.min(itemCount / 20, 1);\n\n // Variance affects confidence (lower variance = higher confidence)\n const varianceConfidence = 1 - Math.min(sizeVariance, 1);\n\n // Combined confidence with weighted average\n return countConfidence * 0.4 + varianceConfidence * 0.6;\n }\n\n /**\n * Computes item rectangles based on layout mode.\n */\n private _computeItemRects(\n itemIds: readonly string[],\n containerDimensions: Dimensions,\n mode: LayoutMode,\n analysis: ContentAnalysis\n ): ReadonlyMap {\n // const _rects = new Map();\n\n switch (mode) {\n case 'grid':\n return this._computeGridRects(itemIds, containerDimensions, analysis);\n case 'list':\n return this._computeListRects(itemIds, containerDimensions, analysis);\n case 'compact':\n return this._computeCompactRects(itemIds, containerDimensions, analysis);\n case 'expanded':\n return this._computeExpandedRects(itemIds, containerDimensions, analysis);\n case 'dense':\n return this._computeDenseRects(itemIds, containerDimensions, analysis);\n case 'sparse':\n return this._computeSparseRects(itemIds, containerDimensions, analysis);\n }\n }\n\n /**\n * Computes grid layout rectangles.\n */\n private _computeGridRects(\n itemIds: readonly string[],\n containerDimensions: Dimensions,\n analysis: ContentAnalysis\n ): Map {\n const rects = new Map();\n const config = this._computeGridConfig(containerDimensions, analysis);\n const { columns, gap, rowHeight } = config;\n\n const columnWidth = (containerDimensions.width - gap * (columns - 1)) / columns;\n const actualRowHeight = rowHeight === 'auto' ? columnWidth / PHI : rowHeight;\n\n itemIds.forEach((id, index) => {\n const col = index % columns;\n const row = Math.floor(index / columns);\n\n rects.set(id, {\n x: col * (columnWidth + gap),\n y: row * (actualRowHeight + gap),\n width: columnWidth,\n height: actualRowHeight,\n scaleX: 1,\n scaleY: 1,\n rotation: 0,\n opacity: 1,\n });\n });\n\n return rects;\n }\n\n /**\n * Computes list layout rectangles.\n */\n private _computeListRects(\n itemIds: readonly string[],\n containerDimensions: Dimensions,\n analysis: ContentAnalysis\n ): Map {\n const rects = new Map();\n const config = this._computeListConfig(containerDimensions, analysis);\n const { gap, itemHeight } = config;\n\n const actualItemHeight = itemHeight === 'auto' ? analysis.averageItemSize.height : itemHeight;\n\n let currentY = 0;\n for (const id of itemIds) {\n rects.set(id, {\n x: 0,\n y: currentY,\n width: containerDimensions.width,\n height: actualItemHeight,\n scaleX: 1,\n scaleY: 1,\n rotation: 0,\n opacity: 1,\n });\n currentY += actualItemHeight + gap;\n }\n\n return rects;\n }\n\n /**\n * Computes compact layout rectangles (tight grid with smaller items).\n */\n private _computeCompactRects(\n itemIds: readonly string[],\n containerDimensions: Dimensions,\n _analysis: ContentAnalysis\n ): Map {\n const rects = new Map();\n const gap = 8;\n const minItemSize = 80;\n const columns = Math.max(2, Math.floor(containerDimensions.width / (minItemSize + gap)));\n const itemSize = (containerDimensions.width - gap * (columns - 1)) / columns;\n\n itemIds.forEach((id, index) => {\n const col = index % columns;\n const row = Math.floor(index / columns);\n\n rects.set(id, {\n x: col * (itemSize + gap),\n y: row * (itemSize + gap),\n width: itemSize,\n height: itemSize,\n scaleX: 1,\n scaleY: 1,\n rotation: 0,\n opacity: 1,\n });\n });\n\n return rects;\n }\n\n /**\n * Computes expanded layout rectangles (larger items with more spacing).\n */\n private _computeExpandedRects(\n itemIds: readonly string[],\n containerDimensions: Dimensions,\n _analysis: ContentAnalysis\n ): Map {\n const rects = new Map();\n const gap = 24;\n const columns = Math.max(1, Math.min(2, Math.floor(containerDimensions.width / 400)));\n const itemWidth = (containerDimensions.width - gap * Math.max(0, columns - 1)) / columns;\n const itemHeight = itemWidth / PHI;\n\n itemIds.forEach((id, index) => {\n const col = index % columns;\n const row = Math.floor(index / columns);\n\n rects.set(id, {\n x: col * (itemWidth + gap),\n y: row * (itemHeight + gap),\n width: itemWidth,\n height: itemHeight,\n scaleX: 1,\n scaleY: 1,\n rotation: 0,\n opacity: 1,\n });\n });\n\n return rects;\n }\n\n /**\n * Computes dense layout rectangles (maximum items per area).\n */\n private _computeDenseRects(\n itemIds: readonly string[],\n containerDimensions: Dimensions,\n _analysis: ContentAnalysis\n ): Map {\n const rects = new Map();\n const gap = 4;\n const minItemSize = 60;\n const columns = Math.max(3, Math.floor(containerDimensions.width / (minItemSize + gap)));\n const itemSize = (containerDimensions.width - gap * (columns - 1)) / columns;\n\n itemIds.forEach((id, index) => {\n const col = index % columns;\n const row = Math.floor(index / columns);\n\n rects.set(id, {\n x: col * (itemSize + gap),\n y: row * (itemSize * 0.75 + gap), // Shorter rows for density\n width: itemSize,\n height: itemSize * 0.75,\n scaleX: 1,\n scaleY: 1,\n rotation: 0,\n opacity: 1,\n });\n });\n\n return rects;\n }\n\n /**\n * Computes sparse layout rectangles (generous spacing for readability).\n */\n private _computeSparseRects(\n itemIds: readonly string[],\n containerDimensions: Dimensions,\n _analysis: ContentAnalysis\n ): Map {\n const rects = new Map();\n const gap = 32;\n const padding = 48;\n const availableWidth = containerDimensions.width - padding * 2;\n const itemWidth = Math.min(600, availableWidth);\n const itemHeight = itemWidth / PHI;\n const startX = (containerDimensions.width - itemWidth) / 2;\n\n let currentY = padding;\n for (const id of itemIds) {\n rects.set(id, {\n x: startX,\n y: currentY,\n width: itemWidth,\n height: itemHeight,\n scaleX: 1,\n scaleY: 1,\n rotation: 0,\n opacity: 1,\n });\n currentY += itemHeight + gap;\n }\n\n return rects;\n }\n\n /**\n * Computes optimal grid configuration.\n */\n private _computeGridConfig(containerDimensions: Dimensions, analysis: ContentAnalysis): GridLayoutConfig {\n const idealItemWidth = analysis.averageItemSize.width || 200;\n const minGap = 16;\n const columns = Math.max(1, Math.floor(containerDimensions.width / (idealItemWidth + minGap)));\n const gap = Math.min(24, (containerDimensions.width - columns * idealItemWidth) / (columns + 1));\n\n return {\n columns,\n gap,\n rowHeight: 'auto',\n autoFlow: 'row',\n itemAlignment: 'stretch',\n };\n }\n\n /**\n * Computes optimal list configuration.\n */\n private _computeListConfig(_containerDimensions: Dimensions, analysis: ContentAnalysis): ListLayoutConfig {\n return {\n gap: 12,\n direction: 'vertical',\n itemHeight: analysis.averageItemSize.height || 'auto',\n alternateRows: analysis.itemCount > 5,\n };\n }\n\n /**\n * Predicts CLS impact of a layout change.\n */\n private _predictCLS(state: LayoutState, animationContext?: { snapshots: ReadonlyMap }): number {\n // If we have animation context, CLS should be near zero due to FLIP\n if (animationContext) {\n return 0.001;\n }\n\n // Estimate based on number of items and their sizes\n const totalArea = Array.from(state.itemRects.values()).reduce(\n (sum, rect) => sum + rect.width * rect.height,\n 0\n );\n const containerArea = state.containerDimensions.width * state.containerDimensions.height;\n\n // CLS is proportional to shifted area\n return containerArea > 0 ? Math.min(0.25, totalArea / containerArea * 0.1) : 0;\n }\n\n /**\n * Initializes user preferences storage.\n */\n private _initializeUserPreferences(): UserLayoutPreferences {\n // Try to load from localStorage\n const stored = typeof window !== 'undefined'\n ? localStorage.getItem('adaptive-layout-preferences')\n : null;\n\n if (stored != null && stored !== '') {\n try {\n const parsed = JSON.parse(stored) as { modePreferences?: Record };\n const { modePreferences } = parsed;\n return {\n modePreferences: new Map(Object.entries(modePreferences ?? {})) as ReadonlyMap,\n animationPreferences: {\n reducedMotion: typeof window !== 'undefined' && window.matchMedia('(prefers-reduced-motion: reduce)').matches,\n preferredDuration: 300,\n preferredEasing: 'ease-out' as const,\n },\n accessibilityPreferences: {\n highContrast: false,\n largeText: false,\n reducedMotion: false,\n screenReader: false,\n },\n lastUpdated: Date.now(),\n };\n } catch {\n // Fall through to default\n }\n }\n\n // Default preferences\n return {\n modePreferences: new Map(),\n animationPreferences: {\n reducedMotion: typeof window !== 'undefined' && window.matchMedia('(prefers-reduced-motion: reduce)').matches,\n preferredDuration: 300,\n preferredEasing: 'ease-out' as const,\n },\n accessibilityPreferences: {\n highContrast: false,\n largeText: false,\n reducedMotion: false,\n screenReader: false,\n },\n lastUpdated: Date.now(),\n };\n }\n\n /**\n * Asserts that the engine has not been destroyed.\n */\n private _assertNotDestroyed(): void {\n if (this._destroyed) {\n throw new Error('LayoutEngine has been destroyed and cannot be used.');\n }\n }\n}\n\n// =============================================================================\n// FACTORY FUNCTION\n// =============================================================================\n\n/**\n * Creates a new LayoutEngine instance.\n *\n * @param config - Optional configuration overrides\n * @returns A new LayoutEngine instance\n *\n * @example\n * ```typescript\n * const engine = createLayoutEngine({\n * contentAware: true,\n * predictiveLayout: true,\n * performanceBudgetMs: 16\n * });\n * ```\n */\nexport function createLayoutEngine(config: Partial = {}): LayoutEngineInterface {\n return new LayoutEngine(config);\n}\n\n/**\n * Singleton layout engine instance for shared use.\n */\nlet sharedEngine: LayoutEngineInterface | null = null;\n\n/**\n * Gets or creates the shared layout engine instance.\n *\n * @param config - Optional configuration (only used on first call)\n * @returns The shared LayoutEngine instance\n */\nexport function getSharedLayoutEngine(config?: Partial): LayoutEngineInterface {\n sharedEngine ??= createLayoutEngine(config);\n return sharedEngine;\n}\n\n/**\n * Resets the shared layout engine (useful for testing).\n */\nexport function resetSharedLayoutEngine(): void {\n if (sharedEngine) {\n sharedEngine.destroy();\n sharedEngine = null;\n }\n}\n"],"names":["PHI","DENSITY_THRESHOLDS","VARIANCE_THRESHOLDS","MIN_ITEMS_FOR_ANALYSIS","calculateStandardDeviation","values","mean","sum","val","avgSquaredDiff","calculateCoefficientOfVariation","classifyAspectRatio","ratio","isImageHeavyContent","element","images","textLength","imageCount","isTextHeavyContent","LayoutEngine","config","DEFAULT_LAYOUT_ENGINE_CONFIG","container","cached","children","itemCount","dimensions","child","rect","widths","d","heights","areas","avgWidth","w","avgHeight","h","avgArea","a","widthVariance","heightVariance","sizeVariance","containerRect","containerArea","totalItemArea","densityRatio","density","aspectRatios","aspectRatioDistribution","imageHeavy","textHeavy","recommendedMode","analysis","request","startTime","containerElement","mode","itemRects","gridConfig","listConfig","computeTimeMs","state","constraints","c","preferredMode","callback","entries","entry","_container","ratios","distribution","total","category","countConfidence","varianceConfidence","itemIds","containerDimensions","rects","columns","gap","rowHeight","columnWidth","actualRowHeight","id","index","col","row","itemHeight","actualItemHeight","currentY","_analysis","itemSize","itemWidth","padding","availableWidth","startX","idealItemWidth","_containerDimensions","animationContext","totalArea","stored","parsed","modePreferences","createLayoutEngine","sharedEngine","getSharedLayoutEngine","resetSharedLayoutEngine"],"mappings":"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"}