{"version":3,"file":"DistanceCalculator.CeXdhK8w.mjs","names":[],"sources":["https:/framerusercontent.com/modules/zVlRz4Ul0PRdIfgI2SHk/eZ067KMryLHfzIMSGZb9/DistanceCalculator.js"],"sourcesContent":["/**\n * @file DistanceCalculator.ts\n * @description Distance calculation utilities for grid-based staggering\n *\n * @version 1.0.0 - Production Implementation\n * @since 1.0.0\n *\n * @example\n * ```typescript\n * import { DistanceCalculator } from './DistanceCalculator.ts';\n *\n * const calculator = new DistanceCalculator();\n * const gridResult = calculator.calculateGridDistances(gridResult, originPoint, 'euclidean');\n *\n * console.log(`Max distance: ${gridResult.maxDistance}`);\n * gridResult.elements.forEach(el => console.log(`Element distance: ${el.distance}`));\n * ```\n */// Module name for logging\nconst MODULE_NAME=\"DistanceCalculator\";/**\n * Distance calculation utilities for grid staggering\n *\n * @description\n * Sophisticated distance calculations for grid-based stagger delays.\n * Supports multiple distance metrics with proper normalization and scaling.\n *\n * **Key Features:**\n * - Multiple distance calculation metrics (euclidean, manhattan, chebyshev, min)\n * - Proper distance normalization for delay calculations\n * - Edge-aware calculations for better edge origin handling\n * - Pixel-accurate distance calculations\n * - Performance optimized for large grids\n *\n * **Distance Metrics:**\n * - **Euclidean**: Standard straight-line distance (most natural)\n * - **Manhattan**: City-block distance (grid-aligned effects)\n * - **Chebyshev**: Maximum dimension distance (square wave effects)\n * - **Min**: Minimum dimension distance (edge-aware)\n */export class DistanceCalculator{/**\n     * Calculate distances from origin to all elements\n     *\n     * @description\n     * Main entry point for distance calculations. Computes distances from a specified\n     * origin point to all grid elements using the selected metric, with proper\n     * normalization for stagger delay calculations.\n     *\n     * **Algorithm Steps:**\n     * 1. Calculate grid bounds in pixel coordinates\n     * 2. Resolve origin point to pixel coordinates\n     * 3. Calculate distance for each element using selected metric\n     * 4. Normalize distances to 0-1 range for delay calculations\n     * 5. Return updated grid result with distance information\n     *\n     * @param gridResult - Grid detection result to calculate distances for\n     * @param originPoint - Origin point in grid coordinates (0-based)\n     * @param metric - Distance calculation metric to use\n     * @returns Updated grid result with calculated distances\n     */calculateGridDistances(gridResult,originPoint,metric=\"euclidean\"){const{elements}=gridResult;if(elements.length===0){console.warn(`🔍 [${MODULE_NAME}] No elements to calculate distances for`);return gridResult;}console.log(`🔍 [${MODULE_NAME}] Calculating distances for ${elements.length} elements using ${metric} metric`);// Calculate grid bounds in pixel coordinates\nconst gridBounds=this.calculateGridBounds(elements);console.log(`🔍 [${MODULE_NAME}] Grid bounds: left=${gridBounds.left}, right=${gridBounds.right}, top=${gridBounds.top}, bottom=${gridBounds.bottom}`);console.log(`🔍 [${MODULE_NAME}] Grid dimensions: ${gridBounds.width}px x ${gridBounds.height}px`);// Convert grid origin point to pixel coordinates\nconst originPixel=this.resolveOriginPixelCoordinates(originPoint,gridResult,gridBounds);console.log(`🔍 [${MODULE_NAME}] Origin grid (${originPoint.x}, ${originPoint.y}) mapped to pixel (${originPixel.x.toFixed(1)}, ${originPixel.y.toFixed(1)})`);// Check if this is an edge origin for special handling\nconst isEdgeOrigin=this.isEdgeOrigin(originPoint,gridResult);// Calculate distances for each element\nlet maxDistance=0;elements.forEach(element=>{const elementCenter=this.getElementCenter(element.element);const distance=this.calculateDistance(originPixel,elementCenter,metric,isEdgeOrigin,originPoint,gridBounds);element.distance=distance;maxDistance=Math.max(maxDistance,distance);console.log(`🔍 [${MODULE_NAME}] Element at grid (${element.position.x}, ${element.position.y}), `+`pixel (${elementCenter.x.toFixed(1)}, ${elementCenter.y.toFixed(1)}), `+`distance: ${distance.toFixed(1)}`);});// Normalize distances to 0-1 range\nelements.forEach(element=>{element.normalizedDistance=maxDistance>0?element.distance/maxDistance:0;console.log(`🔍 [${MODULE_NAME}] Element at (${element.position.x}, ${element.position.y}), `+`normalized distance: ${element.normalizedDistance.toFixed(3)}`);});// Return updated grid result\nreturn{...gridResult,elements,maxDistance};}/**\n     * Calculate distance between two points using specified metric\n     *\n     * @description\n     * Core distance calculation function supporting multiple metrics.\n     * Includes special handling for edge origins and proper metric implementations.\n     *\n     * @param p1 - First point (origin)\n     * @param p2 - Second point (element center)\n     * @param metric - Distance metric to use\n     * @param isEdgeOrigin - Whether origin is at grid edge\n     * @param gridOrigin - Original grid coordinates (for edge detection)\n     * @param gridBounds - Grid bounds (for edge calculations)\n     * @returns Calculated distance\n     */calculateDistance(p1,p2,metric=\"euclidean\",isEdgeOrigin=false,gridOrigin,gridBounds){const dx=p2.x-p1.x;const dy=p2.y-p1.y;switch(metric){case\"euclidean\":return Math.sqrt(dx*dx+dy*dy);case\"manhattan\":return Math.abs(dx)+Math.abs(dy);case\"chebyshev\":case\"max\":return Math.max(Math.abs(dx),Math.abs(dy));case\"min\":// Special handling for edge origins\nif(isEdgeOrigin&&gridOrigin&&gridBounds){return this.calculateEdgeAwareMinDistance(p1,p2,gridOrigin,gridBounds);}return Math.min(Math.abs(dx),Math.abs(dy));default:console.warn(`🔍 [${MODULE_NAME}] Unknown distance metric: ${metric}, falling back to euclidean`);return Math.sqrt(dx*dx+dy*dy);}}/**\n     * Calculate edge-aware minimum distance for better edge origin handling\n     *\n     * @description\n     * Special distance calculation for minimum metric when origin is at an edge.\n     * Uses the primary dimension distance for more intuitive stagger patterns.\n     *\n     * @param originPixel - Origin point in pixels\n     * @param elementPixel - Element center in pixels\n     * @param gridOrigin - Grid coordinates of origin\n     * @param gridBounds - Grid boundary information\n     * @returns Edge-aware distance\n     */calculateEdgeAwareMinDistance(originPixel,elementPixel,gridOrigin,gridBounds){// Check which edge the origin is at\nconst isAtLeftEdge=gridOrigin.x===0;const isAtRightEdge=Math.abs(originPixel.x-gridBounds.right)<5// tolerance for right edge\n;const isAtTopEdge=gridOrigin.y===0;const isAtBottomEdge=Math.abs(originPixel.y-gridBounds.bottom)<5// tolerance for bottom edge\n;const isVerticalCenter=Math.abs(gridOrigin.y*2-(gridBounds.bottom-gridBounds.top))<5;const isHorizontalCenter=Math.abs(gridOrigin.x*2-(gridBounds.right-gridBounds.left))<5;// For edge origins, use the distance along the primary dimension\nif((isAtLeftEdge||isAtRightEdge)&&isVerticalCenter){// Left or right center: use horizontal distance\nreturn Math.abs(elementPixel.x-originPixel.x);}else if((isAtTopEdge||isAtBottomEdge)&&isHorizontalCenter){// Top or bottom center: use vertical distance\nreturn Math.abs(elementPixel.y-originPixel.y);}// Default min behavior for other cases\nconst dx=Math.abs(elementPixel.x-originPixel.x);const dy=Math.abs(elementPixel.y-originPixel.y);return Math.min(dx,dy);}/**\n     * Check if origin point is at a grid edge\n     *\n     * @description\n     * Determines whether the origin point is positioned at any edge of the grid\n     * for special distance calculation handling.\n     *\n     * @param originPoint - Origin point in grid coordinates\n     * @param gridResult - Grid detection result\n     * @returns True if origin is at any edge\n     */isEdgeOrigin(originPoint,gridResult){const isAtLeftEdge=originPoint.x===0;const isAtRightEdge=originPoint.x===gridResult.columns-1;const isAtTopEdge=originPoint.y===0;const isAtBottomEdge=originPoint.y===gridResult.rows-1;return isAtLeftEdge||isAtRightEdge||isAtTopEdge||isAtBottomEdge;}/**\n     * Calculate element center coordinates\n     *\n     * @description\n     * Gets the center point of an element for accurate distance calculations.\n     * Uses the element's bounding rectangle to find the geometric center.\n     *\n     * @param element - Element to get center for\n     * @returns Center coordinates in pixels\n     */getElementCenter(element){const rect=element.getBoundingClientRect();return{x:rect.left+rect.width/2,y:rect.top+rect.height/2};}/**\n     * Calculate grid bounds from elements\n     *\n     * @description\n     * Determines the bounding rectangle that encompasses all grid elements\n     * for accurate origin coordinate resolution.\n     *\n     * @param elements - Grid elements to analyze\n     * @returns Grid boundary rectangle with dimensions\n     */calculateGridBounds(elements){if(elements.length===0){return{left:0,right:0,top:0,bottom:0,width:0,height:0};}let minX=Infinity;let maxX=-Infinity;let minY=Infinity;let maxY=-Infinity;elements.forEach(element=>{const rect=element.pixelPosition;minX=Math.min(minX,rect.left);maxX=Math.max(maxX,rect.left+rect.width);minY=Math.min(minY,rect.top);maxY=Math.max(maxY,rect.top+rect.height);});return{left:minX,right:maxX,top:minY,bottom:maxY,width:maxX-minX,height:maxY-minY};}/**\n     * Resolve origin point to pixel coordinates\n     *\n     * @description\n     * Converts grid-based origin coordinates to precise pixel coordinates\n     * for accurate distance calculations. Handles edge cases and interpolation.\n     *\n     * @param originPoint - Origin point in grid coordinates\n     * @param gridResult - Grid detection result\n     * @param gridBounds - Grid boundary information\n     * @returns Origin point in pixel coordinates\n     */resolveOriginPixelCoordinates(originPoint,gridResult,gridBounds){const{columns,rows}=gridResult;// Handle edge positions precisely\nlet originPixelX;let originPixelY;// X coordinate resolution\nif(originPoint.x===0){// Left edge\noriginPixelX=gridBounds.left;}else if(originPoint.x===columns-1){// Right edge\noriginPixelX=gridBounds.right;}else if(originPoint.x===(columns-1)/2){// Horizontal center\noriginPixelX=gridBounds.left+gridBounds.width/2;}else{// Interpolate proportionally\nconst normalizedX=originPoint.x/Math.max(1,columns-1);originPixelX=gridBounds.left+normalizedX*gridBounds.width;}// Y coordinate resolution\nif(originPoint.y===0){// Top edge\noriginPixelY=gridBounds.top;}else if(originPoint.y===rows-1){// Bottom edge\noriginPixelY=gridBounds.bottom;}else if(originPoint.y===(rows-1)/2){// Vertical center\noriginPixelY=gridBounds.top+gridBounds.height/2;}else{// Interpolate proportionally\nconst normalizedY=originPoint.y/Math.max(1,rows-1);originPixelY=gridBounds.top+normalizedY*gridBounds.height;}return{x:originPixelX,y:originPixelY};}/**\n     * Normalize distances to 0-1 range\n     *\n     * @description\n     * Scales distance array to normalized 0-1 range for delay calculations.\n     * Handles edge cases like identical distances or single elements.\n     *\n     * @param distances - Raw distance array\n     * @returns Normalized distances (0-1)\n     */normalizeDistances(distances){if(distances.length===0)return[];const minDistance=Math.min(...distances);const maxDistance=Math.max(...distances);const range=maxDistance-minDistance;if(range===0){// All distances are the same\nreturn distances.map(()=>0);}return distances.map(distance=>(distance-minDistance)/range);}/**\n     * Group elements by similar distances\n     *\n     * @description\n     * Groups elements with similar distances for simultaneous animation.\n     * Uses tolerance to handle floating point precision issues.\n     *\n     * @param elements - Elements with calculated distances\n     * @param distances - Corresponding distance array\n     * @param tolerance - Grouping tolerance for floating point issues\n     * @returns Map of distance groups\n     */groupByDistance(elements,distances,tolerance=.01){const groups=new Map;elements.forEach((element,index)=>{const distance=distances[index];const roundedDistance=Math.round(distance*1e3)/1e3// Round to 3 decimal places\n;if(!groups.has(roundedDistance)){groups.set(roundedDistance,[]);}groups.get(roundedDistance).push(element);});return groups;}/**\n     * Calculate stagger delays for timed animations\n     *\n     * @description\n     * 🚨 FIXED: Implements progressive delay accumulation instead of total time spreading.\n     * Each delay group is separated by 'amount' seconds for proper stagger timing.\n     *\n     * 🚀 PHASE 1A: Enhanced with proper 2D grid stagger reversal support.\n     * For reverse animations, \"latest\" elements (farthest from origin) start first.\n     *\n     * **Algorithm**:\n     * 1. Group elements by distance (elements at same distance animate together)\n     * 2. Sort distance groups by their distance value\n     * 3. 🚀 NEW: For reverse mode, flip the timing so latest elements start first\n     * 4. Apply incremental delay: each group starts 'amount' seconds after previous\n     * 5. Apply distribution easing to group positions\n     *\n     * **Forward Mode**: delay = groupIndex * amount (closest → farthest)\n     * **Reverse Mode**: delay = (maxGroupIndex - groupIndex) * amount (farthest → closest)\n     *\n     * @param gridResult - Grid result with calculated distances\n     * @param amount - Delay increment between consecutive animation groups (in seconds)\n     * @param distribution - Easing function for delay distribution\n     * @param isReverseAnimation - 🚀 NEW: Whether this is a reverse animation (default: false)\n     * @returns Grid stagger result with corrected timing information\n     */calculateTimedStaggerDelays(gridResult,amount,distribution=\"linear\",isReverseAnimation=false){const{elements}=gridResult;if(elements.length===0){console.warn(`🔍 [${MODULE_NAME}] No elements to calculate delays for`);return{elements:[],delays:[],boundaries:[]};}console.log(`🔍 [${MODULE_NAME}] 🚨 ENHANCED: Calculating progressive stagger delays for ${elements.length} elements with ${amount}s incremental delay, reverse=${isReverseAnimation}`);// 🚨 FIX: Group elements by their normalized distance (with tolerance for floating point issues)\nconst tolerance=.001;const distanceGroups=new Map;elements.forEach(element=>{// Round to 3 decimal places to handle floating point precision\nconst roundedDistance=Math.round(element.normalizedDistance*1e3)/1e3;if(!distanceGroups.has(roundedDistance)){distanceGroups.set(roundedDistance,[]);}distanceGroups.get(roundedDistance).push(element);});// Sort the unique distances to determine animation order\nconst uniqueDistances=Array.from(distanceGroups.keys()).sort((a,b)=>a-b);console.log(`🔍 [${MODULE_NAME}] 🚨 ENHANCED: Found ${uniqueDistances.length} unique distance groups from ${elements.length} elements`);// 🚀 PHASE 1A: Calculate progressive delays with reverse mode support\nconst maxGroupIndex=uniqueDistances.length-1;const delays=elements.map(element=>{// Round the normalized distance to match grouping\nconst roundedDistance=Math.round(element.normalizedDistance*1e3)/1e3;// Find which group this element belongs to\nconst groupIndex=uniqueDistances.indexOf(roundedDistance);// 🚀 CRITICAL ENHANCEMENT: Handle reverse animation timing\nlet finalDelay;if(distribution===\"linear\"||distribution===\"\"){if(isReverseAnimation){// 🚀 REVERSE MODE: Latest elements (farthest from origin) start first\n// Flip the timing: maxGroupIndex becomes 0, 0 becomes maxGroupIndex\nfinalDelay=amount*(maxGroupIndex-groupIndex);console.log(`🔄 [${MODULE_NAME}] 🚀 REVERSE: Element at (${element.position.x}, ${element.position.y}), `+`distance group: ${groupIndex+1}/${uniqueDistances.length}, `+`FLIPPED to position: ${maxGroupIndex-groupIndex+1}/${uniqueDistances.length}, `+`reverse delay: ${finalDelay.toFixed(3)}s`);}else{// FORWARD MODE: Progressive delay from closest to farthest\nfinalDelay=amount*groupIndex;console.log(`🔍 [${MODULE_NAME}] 🚨 FORWARD: Element at (${element.position.x}, ${element.position.y}), `+`distance group: ${groupIndex+1}/${uniqueDistances.length}, `+`progressive delay: ${finalDelay.toFixed(3)}s`);}}else{// Future: Apply easing function to group position\n// Get normalized position in the sequence (0-1)\nconst normalizedPosition=groupIndex/Math.max(1,uniqueDistances.length-1);if(isReverseAnimation){// 🚀 REVERSE MODE: For easing, flip the normalized position\nconst flippedPosition=1-normalizedPosition;finalDelay=amount*(maxGroupIndex-groupIndex);console.log(`🔄 [${MODULE_NAME}] 🚀 REVERSE: Element at (${element.position.x}, ${element.position.y}), `+`normalized position: ${normalizedPosition.toFixed(3)} → flipped: ${flippedPosition.toFixed(3)}, `+`reverse delay: ${finalDelay.toFixed(3)}s (${distribution} distribution)`);}else{// FORWARD MODE: For now, fall back to linear for easing\nfinalDelay=amount*groupIndex;console.log(`🔍 [${MODULE_NAME}] 🚨 FORWARD: Element at (${element.position.x}, ${element.position.y}), `+`normalized position: ${normalizedPosition.toFixed(3)}, `+`progressive delay: ${finalDelay.toFixed(3)}s (${distribution} distribution)`);}}return finalDelay;});// 🚀 PHASE 1A: Log animation order for debugging (enhanced with reverse mode info)\nconst elementsSortedByDelay=[...elements].map((el,idx)=>({...el,delay:delays[idx]})).sort((a,b)=>a.delay-b.delay);const modeLabel=isReverseAnimation?\"🔄 REVERSE\":\"▶️ FORWARD\";console.log(`🔍 [${MODULE_NAME}] 🚀 ENHANCED: ${modeLabel} animation order:`);elementsSortedByDelay.forEach((el,idx)=>{console.log(`${idx+1}. Element at grid (${el.position.x}, ${el.position.y}), `+`delay: ${el.delay.toFixed(3)}s, distance: ${el.normalizedDistance.toFixed(3)}`);});// 🚀 PHASE 1A: Enhanced simultaneous animation group logging\nconst delayGroups=new Map;elementsSortedByDelay.forEach(el=>{const roundedDelay=Math.round(el.delay*1e3)/1e3;if(!delayGroups.has(roundedDelay)){delayGroups.set(roundedDelay,[]);}delayGroups.get(roundedDelay).push(el.index);});console.log(`🔍 [${MODULE_NAME}] 🚀 ENHANCED: ${modeLabel} simultaneous animation groups:`);Array.from(delayGroups.entries()).sort(([a],[b])=>a-b).forEach(([delay,indices])=>{console.log(`Delay ${delay.toFixed(3)}s: Elements [${indices.join(\", \")}]`);});// 🚀 PHASE 1A: Log reverse mode specifics for debugging\nif(isReverseAnimation){console.log(`🔄 [${MODULE_NAME}] 🚀 REVERSE MODE: Latest elements (farthest from origin) start first!`);const firstElements=elementsSortedByDelay.slice(0,Math.min(3,elementsSortedByDelay.length));console.log(`🔄 [${MODULE_NAME}] First to animate (latest elements):`,firstElements.map(el=>`(${el.position.x},${el.position.y})`).join(\", \"));}return{elements,delays,boundaries:[]};}}\nexport const __FramerMetadata__ = {\"exports\":{\"DistanceCalculator\":{\"type\":\"class\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./DistanceCalculator.map"],"mappings":"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"}