@operato/weather 9.0.0-beta.56

package/dist/src/services/weather-service.d.ts

@@ -0,0 +1,79 @@
+import { WeatherService as IWeatherService, Location, WeatherData, WeatherGridData, WeatherServiceOptions } from '../types.js';
+/**
+ * 날씨 데이터를 가져오고 관리하는 서비스 클래스
+ */
+export declare class WeatherService implements IWeatherService {
+    private apiKey?;
+    private endpoint;
+    private cachedData;
+    private lastUpdated?;
+    private updateInterval;
+    private updateTimer?;
+    private onDataUpdate?;
+    /**
+     * 날씨 서비스 생성자
+     * @param options 날씨 서비스 설정 옵션
+     */
+    constructor(options?: WeatherServiceOptions);
+    /**
+     * 날씨 데이터를 가져옵니다.
+     * @param bounds 지도 경계 좌표 (남서, 북동)
+     * @param forceUpdate 강제 업데이트 여부
+     * @returns 최신 날씨 데이터
+     */
+    fetchWeatherData(bounds: [[number, number], [number, number]], forceUpdate?: boolean): Promise<WeatherData[]>;
+    /**
+     * 비동기적으로 모의 날씨 데이터를 생성합니다.
+     * 메인 스레드 차단을 방지하기 위해 청크 단위로 처리합니다.
+     */
+    private generateMockDataAsync;
+    /**
+     * 데이터 업데이트 자동화 시작
+     * @param bounds 지도 경계 좌표
+     * @param callback 데이터 업데이트 시 호출될 콜백 함수
+     */
+    startAutoUpdate(bounds: [[number, number], [number, number]], callback?: (data: WeatherData[]) => void): void;
+    /**
+     * 자동 업데이트 중지
+     */
+    stopAutoUpdate(): void;
+    /**
+     * API 데이터 처리 및 변환
+     * @param apiData API에서 받은 데이터
+     * @returns 변환된 날씨 데이터 배열
+     */
+    private processApiData;
+    /**
+     * 모의 날씨 데이터를 생성합니다.
+     * @param bounds 지도 경계 좌표
+     * @returns 생성된 목업 날씨 데이터
+     */
+    private generateMockData;
+    /**
+     * 위치가 해안 지역인지 확인합니다 (간단한 모의 함수)
+     * @param lng 경도
+     * @param lat 위도
+     * @returns 해안 지역 여부
+     */
+    private isCoastalRegion;
+    /**
+     * 특정 위치의 날씨 정보를 가져옵니다.
+     */
+    getWeatherByLocation(location: Location): Promise<WeatherData>;
+    /**
+     * 특정 위치 주변의 날씨 정보를 그리드 형태로 가져옵니다.
+     */
+    getWeatherAroundLocation(location: Location, radius: number): Promise<WeatherGridData>;
+    /**
+     * 테스트용 날씨 데이터 생성
+     */
+    private generateMockWeatherData;
+    /**
+     * 테스트용 그리드 날씨 데이터 생성
+     */
+    private generateMockWeatherGridData;
+    /**
+     * 구름량에 따른 날씨 설명을 반환합니다.
+     */
+    private getWeatherDescription;
+}

package/dist/src/services/weather-service.js

@@ -0,0 +1,560 @@
+/**
+ * 날씨 데이터를 가져오고 관리하는 서비스 클래스
+ */
+export class WeatherService {
+    /**
+     * 날씨 서비스 생성자
+     * @param options 날씨 서비스 설정 옵션
+     */
+    constructor(options = {}) {
+        this.cachedData = [];
+        this.updateInterval = 30 * 60 * 1000; // 기본 30분
+        this.apiKey = options.apiKey;
+        this.endpoint = options.endpoint || 'https://api.weather.example.com/v1';
+        if (options.updateInterval) {
+            this.updateInterval = options.updateInterval * 1000; // 초 단위를 밀리초로 변환
+        }
+        if (options.mockData) {
+            this.cachedData = options.mockData;
+            this.lastUpdated = new Date();
+        }
+    }
+    /**
+     * 날씨 데이터를 가져옵니다.
+     * @param bounds 지도 경계 좌표 (남서, 북동)
+     * @param forceUpdate 강제 업데이트 여부
+     * @returns 최신 날씨 데이터
+     */
+    async fetchWeatherData(bounds, forceUpdate = false) {
+        console.log('날씨 데이터 요청 - 경계:', bounds, '강제 업데이트:', forceUpdate);
+        // 캐시된 데이터가 있고 강제 업데이트가 아니면 캐시 반환
+        const now = Date.now();
+        const cacheTTL = 5 * 60 * 1000; // 5분 캐시
+        if (!forceUpdate && this.cachedData.length > 0 && this.lastUpdated && now - this.lastUpdated.getTime() < cacheTTL) {
+            console.log('캐시된 날씨 데이터 반환 - 데이터 수:', this.cachedData.length);
+            return Promise.resolve(this.cachedData);
+        }
+        try {
+            // API 호출 (실제 API 키가 있으면 실행)
+            if (this.apiKey && this.endpoint) {
+                try {
+                    console.log('실제 API에서 날씨 데이터 요청 중...');
+                    // API 호출 구현
+                    // const apiData = await this.callAPI(bounds)
+                    // return this.processApiData(apiData)
+                }
+                catch (error) {
+                    console.error('API 데이터 가져오기 실패, 모의 데이터로 대체합니다:', error);
+                }
+            }
+            console.log('모의 날씨 데이터 생성 시작');
+            // 비동기적으로 데이터 생성 (메인 스레드 차단 방지)
+            const mockData = await this.generateMockDataAsync(bounds);
+            // 생성된 데이터 캐싱
+            this.cachedData = mockData;
+            this.lastUpdated = new Date();
+            return mockData;
+        }
+        catch (error) {
+            console.error('날씨 데이터 생성 오류:', error);
+            return this.cachedData.length > 0 ? this.cachedData : [];
+        }
+    }
+    /**
+     * 비동기적으로 모의 날씨 데이터를 생성합니다.
+     * 메인 스레드 차단을 방지하기 위해 청크 단위로 처리합니다.
+     */
+    async generateMockDataAsync(bounds) {
+        return new Promise(resolve => {
+            // 작업을 비동기로 처리하여 UI 차단 방지
+            setTimeout(() => {
+                const mockData = this.generateMockData(bounds);
+                resolve(mockData);
+            }, 0);
+        });
+    }
+    /**
+     * 데이터 업데이트 자동화 시작
+     * @param bounds 지도 경계 좌표
+     * @param callback 데이터 업데이트 시 호출될 콜백 함수
+     */
+    startAutoUpdate(bounds, callback) {
+        if (callback) {
+            this.onDataUpdate = callback;
+        }
+        // 이전 타이머가 있으면 제거
+        if (this.updateTimer) {
+            clearInterval(this.updateTimer);
+        }
+        // 즉시 데이터 갱신
+        this.fetchWeatherData(bounds).then(data => {
+            if (this.onDataUpdate) {
+                this.onDataUpdate(data);
+            }
+        });
+        // 갱신 타이머 설정
+        this.updateTimer = window.setInterval(() => {
+            this.fetchWeatherData(bounds, true).then(data => {
+                if (this.onDataUpdate) {
+                    this.onDataUpdate(data);
+                }
+            });
+        }, this.updateInterval);
+    }
+    /**
+     * 자동 업데이트 중지
+     */
+    stopAutoUpdate() {
+        if (this.updateTimer) {
+            clearInterval(this.updateTimer);
+            this.updateTimer = undefined;
+        }
+    }
+    /**
+     * API 데이터 처리 및 변환
+     * @param apiData API에서 받은 데이터
+     * @returns 변환된 날씨 데이터 배열
+     */
+    processApiData(apiData) {
+        // API 응답 포맷에 맞게 데이터 변환
+        // 실제 API 구현에 따라 수정 필요
+        return apiData.map((item) => ({
+            location: {
+                latitude: item.lat,
+                longitude: item.lon
+            },
+            temperature: {
+                current: item.temp,
+                unit: 'celsius'
+            },
+            wind: {
+                speed: item.wind_speed,
+                direction: item.wind_dir,
+                unit: 'm/s'
+            },
+            cloud: {
+                coverage: item.cloud_cover,
+                height: item.cloud_height
+            },
+            solar: {
+                radiation: item.solar_rad,
+                unit: 'W/m²'
+            },
+            precipitation: {
+                amount: item.precip,
+                probability: item.precip_prob,
+                unit: 'mm'
+            },
+            time: new Date(item.timestamp)
+        }));
+    }
+    /**
+     * 모의 날씨 데이터를 생성합니다.
+     * @param bounds 지도 경계 좌표
+     * @returns 생성된 목업 날씨 데이터
+     */
+    generateMockData(bounds) {
+        // 한반도 및 주변 지역 위치로 제한 (북위 33-39도, 동경 124-132도)
+        const [[swLng, swLat], [neLng, neLat]] = bounds;
+        // 남한 지역 위주의 경계로 제한
+        const minLng = Math.max(swLng, 124.0);
+        const maxLng = Math.min(neLng, 132.0);
+        const minLat = Math.max(swLat, 32.0);
+        const maxLat = Math.min(neLat, 40.0);
+        console.log('모의 날씨 데이터 생성 중 - 제한된 영역:', [
+            [minLng, minLat],
+            [maxLng, maxLat]
+        ]);
+        // 적절한 데이터 밀도 (성능 최적화)
+        const gridSize = 30; // 기존 90에서 30으로 축소
+        const latStep = (maxLat - minLat) / gridSize;
+        const lngStep = (maxLng - minLng) / gridSize;
+        // 날씨 패턴 - 주요 지역만 포함
+        const weatherPatterns = [
+            { center: [126.9, 37.5], type: 'warm', radius: 2.0 }, // 서울 근처
+            { center: [129.0, 35.2], type: 'sunny', radius: 1.5 }, // 부산 근처
+            { center: [126.5, 34.8], type: 'rainy', radius: 2.0 }, // 목포 근처
+            { center: [130.0, 38.0], type: 'cold', radius: 2.5 } // 동해 북부
+        ];
+        const currentDate = new Date();
+        const hour = currentDate.getHours();
+        // 시간에 따른 태양광 베이스 값
+        const baseSolarRadiation = hour >= 6 && hour <= 18 ? 500 + Math.sin(((hour - 6) * Math.PI) / 12) * 500 : 0;
+        // 계절에 따른 기본 온도 (월별)
+        const month = currentDate.getMonth(); // 0(1월)~11(12월)
+        const baseTempByMonth = [0, 2, 8, 15, 20, 25, 28, 28, 22, 15, 8, 2];
+        const baseTemp = baseTempByMonth[month];
+        const mockData = [];
+        let totalPoints = 0;
+        let count = 0;
+        // 희소한 샘플링으로 대표 위치만 선택
+        for (let lat = minLat; lat <= maxLat; lat += latStep) {
+            for (let lng = minLng; lng <= maxLng; lng += lngStep) {
+                totalPoints++;
+                // 75% 정도의 포인트만 생성 (랜덤 샘플링)
+                if (Math.random() > 0.75) {
+                    continue;
+                }
+                count++;
+                // 가장 가까운 날씨 패턴 찾기
+                const nearestPattern = weatherPatterns
+                    .map(pattern => {
+                    const [patternLng, patternLat] = pattern.center;
+                    const distance = Math.sqrt(Math.pow(lng - patternLng, 2) + Math.pow(lat - patternLat, 2));
+                    return { ...pattern, distance };
+                })
+                    .sort((a, b) => a.distance - b.distance)[0];
+                // 패턴에 따른 날씨 변화
+                const patternFactor = Math.max(0, 1 - nearestPattern.distance / nearestPattern.radius);
+                const randomFactor = Math.random() * 0.5; // 약간의 랜덤성 추가
+                // 위도에 따른 온도 변화 (남쪽이 더 따뜻함)
+                const latFactor = (lat - minLat) / (maxLat - minLat); // 0 (남) ~ 1 (북)
+                const latTempAdjust = (1 - latFactor) * 8; // 최대 8도 차이
+                // 기본 온도에 패턴 효과 적용
+                let temp = baseTemp + latTempAdjust;
+                switch (nearestPattern.type) {
+                    case 'warm':
+                        temp += 5 * patternFactor;
+                        break;
+                    case 'cold':
+                        temp -= 8 * patternFactor;
+                        break;
+                    default:
+                        temp += (randomFactor - 0.25) * 2; // -0.5 ~ +0.5
+                }
+                // 구름 양과 강수 확률
+                let cloud = 0;
+                let precipProb = 0;
+                let precipAmount = 0;
+                switch (nearestPattern.type) {
+                    case 'rainy':
+                        cloud = 0.7 + 0.3 * patternFactor + randomFactor * 0.2;
+                        precipProb = Math.min(100, 70 + 30 * patternFactor + randomFactor * 10);
+                        precipAmount = 5 * patternFactor + randomFactor * 3;
+                        break;
+                    case 'sunny':
+                        cloud = 0.1 + randomFactor * 0.2;
+                        precipProb = Math.max(0, randomFactor * 5);
+                        precipAmount = 0;
+                        break;
+                    default:
+                        cloud = 0.3 + randomFactor * 0.4;
+                        precipProb = 10 + randomFactor * 20;
+                        precipAmount = randomFactor * 2;
+                }
+                // 태양광 (구름 양에 따라 감소)
+                const solar = baseSolarRadiation * (1 - cloud * 0.8);
+                // 바람 속도와 방향
+                // 기본 바람 패턴: 저위도에서 고위도로, 바다에서 육지로
+                const isCoastal = this.isCoastalRegion(lng, lat);
+                // 바람 방향 결정 (0-360, 북쪽이 0도, 시계방향)
+                let windDirection = 0;
+                // 계절에 따른 주요 바람 방향
+                if (month >= 11 || month <= 1) {
+                    // 겨울: 북서풍 우세
+                    windDirection = 315 + (Math.random() - 0.5) * 40;
+                }
+                else if (month >= 5 && month <= 8) {
+                    // 여름: 남동풍 우세
+                    windDirection = 135 + (Math.random() - 0.5) * 40;
+                }
+                else {
+                    // 봄/가을: 서풍 우세
+                    windDirection = 270 + (Math.random() - 0.5) * 60;
+                }
+                // 해안가는 낮에는 육지에서 바다로, 밤에는 바다에서 육지로
+                if (isCoastal) {
+                    if (hour >= 10 && hour <= 16) {
+                        // 낮
+                        windDirection = (windDirection + 60) % 360;
+                    }
+                    else if (hour >= 22 || hour <= 4) {
+                        // 밤
+                        windDirection = (windDirection - 60 + 360) % 360;
+                    }
+                }
+                // 패턴에 따른 풍속 조정
+                let windSpeed = 0;
+                switch (nearestPattern.type) {
+                    case 'rainy':
+                        // 비 구역은 바람이 더 강함
+                        windSpeed = 5 + 10 * patternFactor + randomFactor * 3;
+                        break;
+                    case 'warm':
+                        // 따뜻한 지역은 바람이 약함
+                        windSpeed = 2 + randomFactor * 3;
+                        break;
+                    case 'cold':
+                        // 추운 지역은 바람이 강함
+                        windSpeed = 6 + 8 * patternFactor + randomFactor * 3;
+                        break;
+                    default:
+                        windSpeed = 3 + randomFactor * 5;
+                }
+                // 고도에 따른 풍속 증가 (높은 위도에서 더 강함)
+                windSpeed *= 1 + latFactor * 0.5;
+                // 풍속 범위 제한 (0.5 ~ 20 m/s)
+                windSpeed = Math.max(0.5, Math.min(20, windSpeed));
+                // 날씨 데이터 객체 생성
+                mockData.push({
+                    location: {
+                        latitude: lat,
+                        longitude: lng
+                    },
+                    temperature: {
+                        current: Number(temp.toFixed(1)),
+                        unit: 'celsius'
+                    },
+                    wind: {
+                        speed: Number(windSpeed.toFixed(1)),
+                        direction: Math.round(windDirection),
+                        unit: 'm/s'
+                    },
+                    cloud: {
+                        coverage: Number((cloud * 100).toFixed(0)),
+                        height: 1000 + Math.random() * 2000
+                    },
+                    solar: {
+                        radiation: Number(solar.toFixed(0)),
+                        unit: 'W/m²'
+                    },
+                    precipitation: {
+                        amount: Number(precipAmount.toFixed(1)),
+                        probability: Math.round(precipProb),
+                        unit: 'mm'
+                    },
+                    time: new Date()
+                });
+            }
+        }
+        console.log(`모의 날씨 데이터 생성 완료: 총 ${count}개 생성 (전체 격자 중 ${totalPoints}개)`);
+        console.log('샘플 데이터:', mockData.length > 0
+            ? [
+                {
+                    location: mockData[0].location,
+                    temp: mockData[0].temperature.current,
+                    wind: mockData[0].wind,
+                    solar: mockData[0].solar
+                },
+                {
+                    location: mockData[Math.floor(mockData.length / 2)].location,
+                    temp: mockData[Math.floor(mockData.length / 2)].temperature.current,
+                    wind: mockData[Math.floor(mockData.length / 2)].wind,
+                    solar: mockData[Math.floor(mockData.length / 2)].solar
+                }
+            ]
+            : 'No data');
+        return mockData;
+    }
+    /**
+     * 위치가 해안 지역인지 확인합니다 (간단한 모의 함수)
+     * @param lng 경도
+     * @param lat 위도
+     * @returns 해안 지역 여부
+     */
+    isCoastalRegion(lng, lat) {
+        // 한반도 해안선 근사:
+        // 서해안: ~126-126.6도
+        // 동해안: ~129-130도
+        // 남해안: ~34.4-35도
+        // 서해안
+        if (125.9 <= lng && lng <= 126.7 && lat >= 34.5) {
+            return true;
+        }
+        // 동해안
+        if (128.8 <= lng && lng <= 130.1 && lat >= 35.0) {
+            return true;
+        }
+        // 남해안
+        if (126.5 <= lng && lng <= 129.3 && 34.3 <= lat && lat <= 35.1) {
+            return true;
+        }
+        // 제주도 주변
+        if (126.0 <= lng && lng <= 127.0 && 33.0 <= lat && lat <= 33.6) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 특정 위치의 날씨 정보를 가져옵니다.
+     */
+    async getWeatherByLocation(location) {
+        // 실제 구현에서는 API 호출 등으로 데이터를 가져옵니다.
+        // 테스트를 위해 임시 데이터를 생성합니다.
+        return this.generateMockWeatherData(location);
+    }
+    /**
+     * 특정 위치 주변의 날씨 정보를 그리드 형태로 가져옵니다.
+     */
+    async getWeatherAroundLocation(location, radius) {
+        return this.generateMockWeatherGridData(location, radius);
+    }
+    /**
+     * 테스트용 날씨 데이터 생성
+     */
+    generateMockWeatherData(location) {
+        const cloudCoverage = Math.random() * 100;
+        const solarRadiation = Math.random() * 1000;
+        const currentTime = new Date();
+        return {
+            location,
+            temperature: {
+                current: 20 + Math.random() * 10,
+                unit: '°C'
+            },
+            wind: {
+                speed: 5 + Math.random() * 20,
+                unit: 'km/h',
+                direction: Math.random() * 360
+            },
+            humidity: 30 + Math.random() * 50,
+            cloud: {
+                coverage: cloudCoverage,
+                height: 1000 + Math.random() * 2000
+            },
+            cloudCoverage,
+            solar: {
+                radiation: solarRadiation,
+                unit: 'W/m²'
+            },
+            solarRadiation,
+            precipitation: {
+                amount: Math.random() * 10,
+                probability: Math.random() * 100
+            },
+            weatherDescription: this.getWeatherDescription(cloudCoverage),
+            time: currentTime,
+            timestamp: currentTime.toISOString()
+        };
+    }
+    /**
+     * 테스트용 그리드 날씨 데이터 생성
+     */
+    generateMockWeatherGridData(center, radius) {
+        const gridSize = {
+            rows: 10,
+            cols: 10
+        };
+        const latRange = radius / 111; // 대략적인 위도 1도당 111km
+        const lonRange = radius / (111 * Math.cos((center.latitude * Math.PI) / 180));
+        const bounds = {
+            north: center.latitude + latRange,
+            south: center.latitude - latRange,
+            east: center.longitude + lonRange,
+            west: center.longitude - lonRange
+        };
+        const data = [];
+        // 격자별 위치 계산
+        const latStep = (bounds.north - bounds.south) / gridSize.rows;
+        const lonStep = (bounds.east - bounds.west) / gridSize.cols;
+        // 기상 현상 중심점 생성
+        const weatherCenters = [
+            { i: gridSize.rows * 0.3, j: gridSize.cols * 0.3, type: 'storm' },
+            { i: gridSize.rows * 0.7, j: gridSize.cols * 0.7, type: 'heat' },
+            { i: gridSize.rows * 0.5, j: gridSize.cols * 0.2, type: 'cold' },
+            { i: gridSize.rows * 0.2, j: gridSize.cols * 0.8, type: 'rain' }
+        ];
+        for (let i = 0; i < gridSize.rows; i++) {
+            data[i] = [];
+            for (let j = 0; j < gridSize.cols; j++) {
+                const lat = bounds.south + i * latStep;
+                const lon = bounds.west + j * lonStep;
+                // 각 기상 현상 중심점으로부터의 영향 계산
+                let tempEffect = 0;
+                let windEffect = 0;
+                let cloudEffect = 0;
+                let solarEffect = 0;
+                let rainEffect = 0;
+                weatherCenters.forEach(center => {
+                    const dist = Math.sqrt(Math.pow(i - center.i, 2) + Math.pow(j - center.j, 2));
+                    const influence = Math.exp(-dist / 15); // 거리에 따른 영향력 감소
+                    switch (center.type) {
+                        case 'storm':
+                            windEffect += influence * 2;
+                            cloudEffect += influence * 1.5;
+                            rainEffect += influence;
+                            tempEffect -= influence * 5;
+                            solarEffect -= influence;
+                            break;
+                        case 'heat':
+                            tempEffect += influence * 10;
+                            solarEffect += influence;
+                            break;
+                        case 'cold':
+                            tempEffect -= influence * 10;
+                            cloudEffect += influence * 0.5;
+                            break;
+                        case 'rain':
+                            rainEffect += influence * 2;
+                            cloudEffect += influence;
+                            solarEffect -= influence;
+                            break;
+                    }
+                });
+                // 바람 방향 계산 (기상 현상 중심에서 멀어지는 방향)
+                let windDirection = 0;
+                weatherCenters.forEach(center => {
+                    const dx = j - center.j;
+                    const dy = i - center.i;
+                    const dist = Math.sqrt(dx * dx + dy * dy);
+                    if (dist > 0) {
+                        const dir = Math.atan2(dx, dy) * (180 / Math.PI);
+                        windDirection += dir;
+                    }
+                });
+                windDirection = (windDirection / weatherCenters.length + 360) % 360;
+                // 날씨 데이터 생성
+                data[i][j] = {
+                    location: { latitude: lat, longitude: lon },
+                    temperature: {
+                        current: 20 + tempEffect,
+                        unit: '°C'
+                    },
+                    wind: {
+                        speed: 5 + windEffect * 10,
+                        unit: 'km/h',
+                        direction: windDirection
+                    },
+                    humidity: Math.min(100, Math.max(0, 50 + rainEffect * 20 + cloudEffect * 10)),
+                    cloudCoverage: Math.min(100, Math.max(0, 20 + cloudEffect * 50)),
+                    solarRadiation: Math.max(0, 500 + solarEffect * 300),
+                    precipitation: {
+                        amount: Math.max(0, rainEffect * 5),
+                        probability: Math.min(100, Math.max(0, rainEffect * 70))
+                    },
+                    weatherDescription: this.getWeatherDescription(cloudEffect * 100 + rainEffect * 50),
+                    time: new Date(),
+                    cloud: {
+                        coverage: Math.min(100, Math.max(0, 20 + cloudEffect * 50)),
+                        height: 1000 + Math.random() * 2000
+                    },
+                    solar: {
+                        radiation: Math.max(0, 500 + solarEffect * 300),
+                        unit: 'W/m²'
+                    },
+                    timestamp: new Date().toISOString()
+                };
+            }
+        }
+        return {
+            bounds,
+            gridSize,
+            data
+        };
+    }
+    /**
+     * 구름량에 따른 날씨 설명을 반환합니다.
+     */
+    getWeatherDescription(cloudcover) {
+        if (cloudcover < 10)
+            return '맑음';
+        if (cloudcover < 30)
+            return '대체로 맑음';
+        if (cloudcover < 60)
+            return '구름 조금';
+        if (cloudcover < 90)
+            return '대체로 흐림';
+        return '흐림';
+    }
+}
+//# sourceMappingURL=weather-service.js.map