daiso 1.2.8 → 1.2.9

package/dist/services/megabox/location.js

@@ -1,14 +1,12 @@
 /**
  * 메가박스 위치 해석 및 근처 지점 조회 보조 모듈
  */
-import { fetchJson } from '../../utils/http.js';
+import { geocodeLocation, validKoreanCoordinates } from '../../utils/geocode.js';
 import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo } from './client.js';
 const DEFAULT_LATITUDE = 37.5665;
 const DEFAULT_LONGITUDE = 126.978;
 const DEFAULT_AREA_CODE = '11';
 const DEFAULT_TIMEOUT_MS = 15000;
-const GEOCODE_CACHE_TTL_MS = 60 * 60 * 1000;
-const megaboxGeocodeCache = new Map();
 const MEGABOX_AREA_CODE_BY_REGION = [
     ['서울특별시', '11'],
     ['서울', '11'],
@@ -69,94 +67,31 @@ function resolveAreaCodeFromText(text) {
     }
     return null;
 }
-function resolveAreaCodeFromGeocodeResult(result) {
-    for (const component of result.address_components || []) {
-        const candidates = [component.long_name || '', component.short_name || ''];
-        for (const candidate of candidates) {
-            const areaCode = resolveAreaCodeFromText(candidate);
-            if (areaCode) {
-                return areaCode;
-            }
-        }
-    }
-    return resolveAreaCodeFromText(result.formatted_address || '');
-}
-async function geocodeMegaboxLocation(params, options = {}) {
-    const apiKey = (options.googleMapsApiKey || '').trim();
-    if (apiKey.length === 0) {
-        return null;
-    }
-    const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
-    const keyword = (params.keyword || '').trim();
-    if (!hasCoordinates && keyword.length === 0) {
-        return null;
-    }
-    const cacheKey = hasCoordinates ? `coords:${params.latitude},${params.longitude}` : `keyword:${keyword}`;
-    const cached = megaboxGeocodeCache.get(cacheKey);
-    if (cached && cached.expiresAt > Date.now()) {
-        return cached.value;
-    }
-    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
-    if (hasCoordinates) {
-        endpoint.searchParams.set('latlng', `${params.latitude},${params.longitude}`);
-    }
-    else {
-        endpoint.searchParams.set('address', keyword);
-    }
-    endpoint.searchParams.set('key', apiKey);
-    const body = await fetchJson(endpoint.toString(), {
-        method: 'GET',
-        timeout: options.timeout || DEFAULT_TIMEOUT_MS,
-        headers: {
-            Accept: 'application/json',
-        },
-    });
-    if (body.status !== 'OK') {
-        megaboxGeocodeCache.set(cacheKey, {
-            expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
-            value: null,
-        });
-        return null;
-    }
-    const firstResult = body.results?.[0];
-    const latitude = firstResult?.geometry?.location?.lat;
-    const longitude = firstResult?.geometry?.location?.lng;
-    const areaCode = firstResult ? resolveAreaCodeFromGeocodeResult(firstResult) : null;
-    const value = typeof latitude === 'number' && typeof longitude === 'number'
-        ? { latitude, longitude, areaCode }
-        : null;
-    megaboxGeocodeCache.set(cacheKey, {
-        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
-        value,
-    });
-    return value;
-}
 export async function resolveMegaboxLocation(params, options = {}) {
     const explicitAreaCode = (params.areaCode || '').trim();
     const keyword = (params.keyword || '').trim();
     const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
-    let latitude = hasCoordinates ? params.latitude : DEFAULT_LATITUDE;
-    let longitude = hasCoordinates ? params.longitude : DEFAULT_LONGITUDE;
-    let areaCode = explicitAreaCode || '';
-    let geocodeUsed = false;
-    if (!explicitAreaCode || !hasCoordinates) {
-        const geocoded = await geocodeMegaboxLocation(params, options);
-        if (geocoded) {
-            if (!hasCoordinates) {
-                latitude = geocoded.latitude;
-                longitude = geocoded.longitude;
-            }
-            if (!explicitAreaCode && geocoded.areaCode) {
-                areaCode = geocoded.areaCode;
-            }
-            geocodeUsed = true;
-        }
-    }
+    if (hasCoordinates &&
+        !validKoreanCoordinates(params.latitude, params.longitude))
+        throw new Error('유효한 위도/경도를 입력해주세요.');
+    const geocoded = !hasCoordinates && keyword ? await geocodeLocation(keyword, options) : null;
+    if (keyword && !hasCoordinates && !geocoded)
+        throw new Error(`위치를 좌표로 변환하지 못했습니다: ${keyword}`);
+    const latitude = hasCoordinates
+        ? params.latitude
+        : (geocoded?.latitude ?? DEFAULT_LATITUDE);
+    const longitude = hasCoordinates
+        ? params.longitude
+        : (geocoded?.longitude ?? DEFAULT_LONGITUDE);
+    const areaCode = explicitAreaCode ||
+        resolveAreaCodeFromText(geocoded?.formattedAddress || keyword) ||
+        (hasCoordinates ? '' : DEFAULT_AREA_CODE);
+    const geocodeUsed = Boolean(geocoded);
     return {
         keyword: keyword.length > 0 ? keyword : null,
         latitude,
         longitude,
-        areaCode: areaCode || DEFAULT_AREA_CODE,
+        areaCode,
         geocodeUsed,
     };
 }
@@ -215,5 +150,5 @@ export async function resolveMegaboxNearestTheater(params, options = {}) {
     };
 }
 export function __testOnlyClearMegaboxLocationCaches() {
-    megaboxGeocodeCache.clear();
+    // 캐시를 유지하지 않으므로 초기화할 상태가 없습니다.
 }

package/dist/services/megabox/tools/findNearbyTheaters.js

@@ -4,7 +4,7 @@
 import * as z from 'zod';
 import { toYyyymmdd } from '../client.js';
 import { fetchMegaboxNearbyTheaters } from '../location.js';
-async function findNearbyTheaters(args) {
+async function findNearbyTheaters(args, geocodeOptions = {}) {
     const { keyword, latitude, longitude, playDate = toYyyymmdd(), areaCode, limit = 10, timeoutMs = 15000, } = args;
     const result = await fetchMegaboxNearbyTheaters({
         keyword,
@@ -15,14 +15,14 @@ async function findNearbyTheaters(args) {
         limit,
         timeout: timeoutMs,
     }, {
-        googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+        ...geocodeOptions,
         timeout: timeoutMs,
     });
     return {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createFindNearbyTheatersTool() {
+export function createFindNearbyTheatersTool(geocodeOptions = {}) {
     return {
         name: 'megabox_find_nearby_theaters',
         metadata: {
@@ -30,14 +30,14 @@ export function createFindNearbyTheatersTool() {
             description: '사용자 좌표 또는 위치 키워드 기준으로 메가박스 지점을 거리순으로 조회합니다.',
             inputSchema: {
                 keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
-                latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
-                longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
+                latitude: z.number().optional().describe('위도 (미입력 시 keyword 해석)'),
+                longitude: z.number().optional().describe('경도 (미입력 시 keyword 해석)'),
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
-                areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
+                areaCode: z.string().optional().describe('지역 코드 (미입력 시 위치로 결정)'),
                 limit: z.number().optional().default(10).describe('반환할 최대 지점 수 (기본값: 10)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: findNearbyTheaters,
+        handler: ((args) => findNearbyTheaters(args, geocodeOptions)),
     };
 }

package/dist/services/megabox/tools/getRemainingSeats.js

@@ -4,7 +4,7 @@
 import * as z from 'zod';
 import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
 import { resolveMegaboxNearestTheater } from '../location.js';
-async function getRemainingSeats(args) {
+async function getRemainingSeats(args, geocodeOptions = {}) {
     const { playDate = toYyyymmdd(), theaterId: inputTheaterId, movieId, keyword, latitude, longitude, areaCode, limit = 50, timeoutMs = 15000, } = args;
     let theaterId = inputTheaterId;
     let resolvedTheater = null;
@@ -18,7 +18,7 @@ async function getRemainingSeats(args) {
             playDate,
             timeout: timeoutMs,
         }, {
-            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            ...geocodeOptions,
             timeout: timeoutMs,
         });
         theaterId = resolved.theater?.theaterId;
@@ -62,7 +62,7 @@ async function getRemainingSeats(args) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createGetRemainingSeatsTool() {
+export function createGetRemainingSeatsTool(geocodeOptions = {}) {
     return {
         name: 'megabox_get_remaining_seats',
         metadata: {
@@ -75,11 +75,11 @@ export function createGetRemainingSeatsTool() {
                 keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
                 latitude: z.number().optional().describe('위도'),
                 longitude: z.number().optional().describe('경도'),
-                areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
+                areaCode: z.string().optional().describe('지역 코드 (미입력 시 위치로 결정)'),
                 limit: z.number().optional().default(50).describe('반환할 최대 회차 수 (기본값: 50)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: getRemainingSeats,
+        handler: ((args) => getRemainingSeats(args, geocodeOptions)),
     };
 }

package/dist/services/megabox/tools/listNowShowing.js

@@ -4,7 +4,7 @@
 import * as z from 'zod';
 import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
 import { resolveMegaboxNearestTheater } from '../location.js';
-async function listNowShowing(args) {
+async function listNowShowing(args, geocodeOptions = {}) {
     const { playDate = toYyyymmdd(), theaterId: inputTheaterId, movieId, keyword, latitude, longitude, areaCode, timeoutMs = 15000, } = args;
     let theaterId = inputTheaterId;
     let resolvedTheater = null;
@@ -18,7 +18,7 @@ async function listNowShowing(args) {
             playDate,
             timeout: timeoutMs,
         }, {
-            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            ...geocodeOptions,
             timeout: timeoutMs,
         });
         theaterId = resolved.theater?.theaterId;
@@ -57,7 +57,7 @@ async function listNowShowing(args) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createListNowShowingTool() {
+export function createListNowShowingTool(geocodeOptions = {}) {
     return {
         name: 'megabox_list_now_showing',
         metadata: {
@@ -70,10 +70,10 @@ export function createListNowShowingTool() {
                 keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
                 latitude: z.number().optional().describe('위도'),
                 longitude: z.number().optional().describe('경도'),
-                areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
+                areaCode: z.string().optional().describe('지역 코드 (미입력 시 위치로 결정)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: listNowShowing,
+        handler: ((args) => listNowShowing(args, geocodeOptions)),
     };
 }

package/dist/services/opinet/client.js

@@ -180,7 +180,7 @@ export async function fetchOpinetLowestStations(params, options = {}) {
 }
 export async function fetchOpinetStationsAround(params, options = {}) {
     const resolvedLocation = await resolveOpinetLocation(params, {
-        googleMapsApiKey: options.googleMapsApiKey,
+        ...options,
         timeoutMs: options.timeoutMs,
         fetchImpl: options.fetchImpl,
     });

package/dist/services/opinet/index.js

@@ -15,7 +15,7 @@ class OpinetService {
         return [
             createOpinetAveragePricesTool(this.options.apiKey),
             createOpinetLowestStationsTool(this.options.apiKey),
-            createOpinetStationsAroundTool(this.options.apiKey, this.options.googleMapsApiKey),
+            createOpinetStationsAroundTool(this.options.apiKey, this.options.googleMapsApiKey, this.options),
             createOpinetStationDetailTool(this.options.apiKey),
         ];
     }

package/dist/services/opinet/location.js

@@ -1,14 +1,9 @@
+import { geocodeLocation as resolveFreeLocation, validKoreanCoordinates, } from '../../utils/geocode.js';
 import proj4 from 'proj4';
 const WGS84 = 'EPSG:4326';
 const KATEC = 'KATEC';
 const KATEC_PROJ4 = '+proj=tmerc +lat_0=38 +lon_0=128 +k=0.9999 +x_0=400000 +y_0=600000 +ellps=bessel +units=m +no_defs +towgs84=-115.80,474.99,674.11,1.16,-2.31,-1.63,6.43';
 proj4.defs(KATEC, KATEC_PROJ4);
-const GEOCODE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-const geocodeCache = new Map();
-function getProcessEnvValue(name) {
-    /* c8 ignore next -- Worker 런타임은 bindings로 키를 주입합니다. */
-    return typeof process !== 'undefined' ? process.env[name] : undefined;
-}
 function isFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
 }
@@ -23,55 +18,7 @@ export function wgs84ToKatec(latitude, longitude) {
     };
 }
 async function geocodeLocation(location, options) {
-    const keyword = location.trim();
-    const cached = geocodeCache.get(keyword);
-    if (cached && cached.expiresAt > Date.now()) {
-        return cached.value;
-    }
-    const apiKey = options.googleMapsApiKey?.trim() || getProcessEnvValue('GOOGLE_MAPS_API_KEY')?.trim();
-    if (!apiKey) {
-        throw new Error('location 검색에는 GOOGLE_MAPS_API_KEY가 필요합니다.');
-    }
-    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
-    endpoint.searchParams.set('address', keyword);
-    endpoint.searchParams.set('key', apiKey);
-    const response = await (options.fetchImpl ?? fetch)(endpoint.toString(), {
-        headers: { Accept: 'application/json' },
-        signal: AbortSignal.timeout(options.timeoutMs ?? 10000),
-    });
-    const bodyText = await response.text();
-    let parsed;
-    try {
-        parsed = JSON.parse(bodyText);
-    }
-    catch {
-        parsed = { status: 'INVALID_JSON' };
-    }
-    if (!response.ok) {
-        throw new Error(`Google Geocoding 호출 실패: HTTP ${response.status} ${bodyText}`);
-    }
-    if (parsed.status !== 'OK') {
-        geocodeCache.set(keyword, {
-            expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
-            value: null,
-        });
-        return null;
-    }
-    const first = parsed.results?.[0];
-    const latitude = first?.geometry?.location?.lat;
-    const longitude = first?.geometry?.location?.lng;
-    const value = isFiniteNumber(latitude) && isFiniteNumber(longitude)
-        ? {
-            latitude,
-            longitude,
-            formattedAddress: first?.formatted_address ?? null,
-        }
-        : null;
-    geocodeCache.set(keyword, {
-        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
-        value,
-    });
-    return value;
+    return resolveFreeLocation(location, options);
 }
 export async function resolveOpinetLocation(input, options = {}) {
     if (isFiniteNumber(input.x) && isFiniteNumber(input.y)) {
@@ -86,6 +33,8 @@ export async function resolveOpinetLocation(input, options = {}) {
         };
     }
     if (isFiniteNumber(input.latitude) && isFiniteNumber(input.longitude)) {
+        if (!validKoreanCoordinates(input.latitude, input.longitude))
+            throw new Error('유효한 위도/경도를 입력해주세요.');
         return {
             katec: wgs84ToKatec(input.latitude, input.longitude),
             latitude: input.latitude,
@@ -115,5 +64,5 @@ export async function resolveOpinetLocation(input, options = {}) {
     throw new Error('KATEC x/y, 위도/경도(latitude/longitude), 또는 location 중 하나를 입력해주세요.');
 }
 export function __testOnlyClearOpinetGeocodeCache() {
-    geocodeCache.clear();
+    // 캐시를 유지하지 않으므로 초기화할 상태가 없습니다.
 }

package/dist/services/opinet/tools.js

@@ -39,7 +39,7 @@ export function createOpinetLowestStationsTool(apiKey) {
         handler: (async (args) => buildTextResponse(await fetchOpinetLowestStations(args, { apiKey, timeoutMs: args.timeoutMs }))),
     };
 }
-export function createOpinetStationsAroundTool(apiKey, googleMapsApiKey) {
+export function createOpinetStationsAroundTool(apiKey, googleMapsApiKey, geocodeOptions = {}) {
     return {
         name: 'opinet_search_stations_around',
         metadata: {
@@ -61,7 +61,7 @@ export function createOpinetStationsAroundTool(apiKey, googleMapsApiKey) {
                 timeoutMs: z.number().optional().default(10000).describe('요청 제한 시간(ms)'),
             },
         },
-        handler: (async (args) => buildTextResponse(await fetchOpinetStationsAround(args, { apiKey, googleMapsApiKey, timeoutMs: args.timeoutMs }))),
+        handler: (async (args) => buildTextResponse(await fetchOpinetStationsAround(args, { ...geocodeOptions, apiKey, googleMapsApiKey, timeoutMs: args.timeoutMs }))),
     };
 }
 export function createOpinetStationDetailTool(apiKey) {

package/dist/utils/geocode.js

@@ -0,0 +1,155 @@
+import { fetchJson } from './http.js';
+import { searchNaverLocalPlaces } from '../services/places/client.js';
+function validKakaoDocument(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const document = value;
+    return ['place_name', 'address_name', 'road_address_name'].every((field) => document[field] === undefined || typeof document[field] === 'string');
+}
+export function readGeocodeEnvironment() {
+    const env = typeof process === 'undefined' ? {} : process.env;
+    return {
+        kakaoRestApiKey: env.KAKAO_REST_API_KEY,
+        naverClientId: env.NAVER_CLIENT_ID,
+        naverClientSecret: env.NAVER_CLIENT_SECRET,
+    };
+}
+export function geocodeBindings(bindings) {
+    return {
+        kakaoRestApiKey: bindings?.KAKAO_REST_API_KEY,
+        naverClientId: bindings?.NAVER_CLIENT_ID,
+        naverClientSecret: bindings?.NAVER_CLIENT_SECRET,
+    };
+}
+export function validKoreanCoordinates(latitude, longitude) {
+    return (Number.isFinite(latitude) &&
+        Number.isFinite(longitude) &&
+        latitude >= 33 &&
+        latitude <= 39 &&
+        longitude >= 124 &&
+        longitude <= 132);
+}
+const normalize = (value) => value
+    .replace(/특별자치시|특별자치도|특별시|광역시/gu, '')
+    .replace(/경기도/gu, '경기')
+    .replace(/충청북도/gu, '충북')
+    .replace(/충청남도/gu, '충남')
+    .replace(/전라북도|전북특별자치도/gu, '전북')
+    .replace(/전라남도/gu, '전남')
+    .replace(/경상북도/gu, '경북')
+    .replace(/경상남도/gu, '경남')
+    .replace(/강원도/gu, '강원')
+    .replace(/제주도/gu, '제주')
+    .replace(/[^0-9a-z가-힣]/giu, '')
+    .toLowerCase();
+function matches(query, value) {
+    const tokens = query
+        .replace(/^대한민국\s*/u, '')
+        .match(/[0-9]+(?:-[0-9]+)?|[a-z가-힣]+/giu)
+        ?.map((token) => (/^\d/u.test(token) ? token : normalize(token))) || [];
+    const normalized = normalize(value);
+    return (tokens.length > 0 &&
+        tokens.every((token) => /^\d+(?:-\d+)?$/u.test(token)
+            ? value.match(/\d+(?:-\d+)?/gu)?.includes(token)
+            : token.endsWith('역')
+                ? new RegExp(`${token}(?:[0-9]+호선|$|[^가-힣])`, 'u').test(value)
+                : normalized.includes(token)));
+}
+function matchesAddress(query, address) {
+    // 주소 검색은 숫자 존재뿐 아니라 도로 번호와 건물 번호의 순서도 검증합니다.
+    return (matches(query, address) &&
+        query.match(/\d+(?:-\d+)?/gu).join(',') === address.match(/\d+(?:-\d+)?/gu).join(','));
+}
+export async function searchKakaoPlaces(query, options, coordinates) {
+    const key = (options.kakaoRestApiKey ?? readGeocodeEnvironment().kakaoRestApiKey)?.trim();
+    if (!key)
+        return [];
+    const endpoint = new URL('https://dapi.kakao.com/v2/local/search/keyword.json');
+    endpoint.searchParams.set('query', query);
+    endpoint.searchParams.set('size', '15');
+    if (coordinates) {
+        endpoint.searchParams.set('x', String(coordinates.longitude));
+        endpoint.searchParams.set('y', String(coordinates.latitude));
+        endpoint.searchParams.set('radius', '20000');
+        endpoint.searchParams.set('sort', 'distance');
+    }
+    const body = await fetchJson(endpoint.toString(), {
+        fetchImpl: options.fetchImpl,
+        headers: { Authorization: `KakaoAK ${key}` },
+        timeout: options.timeout ?? options.timeoutMs ?? 10000,
+    });
+    return Array.isArray(body.documents) ? body.documents.filter(validKakaoDocument) : [];
+}
+export async function geocodeLocation(query, input = {}) {
+    const keyword = query.trim();
+    if (!keyword)
+        return null;
+    const env = readGeocodeEnvironment();
+    const options = {
+        ...input,
+        kakaoRestApiKey: input.kakaoRestApiKey ?? env.kakaoRestApiKey,
+        naverClientId: input.naverClientId ?? env.naverClientId,
+        naverClientSecret: input.naverClientSecret ?? env.naverClientSecret,
+    };
+    const isAddress = /(?:로|길|동|읍|면|리)\s*\d/u.test(keyword);
+    let documents = [];
+    if (options.kakaoRestApiKey?.trim()) {
+        try {
+            if (isAddress) {
+                const endpoint = new URL('https://dapi.kakao.com/v2/local/search/address.json');
+                endpoint.searchParams.set('query', keyword);
+                const body = await fetchJson(endpoint.toString(), {
+                    fetchImpl: options.fetchImpl,
+                    headers: { Authorization: `KakaoAK ${options.kakaoRestApiKey.trim()}` },
+                    timeout: options.timeout ?? options.timeoutMs ?? 10000,
+                });
+                documents = Array.isArray(body.documents) ? body.documents.filter(validKakaoDocument) : [];
+            }
+            else
+                documents = await searchKakaoPlaces(keyword, options);
+        }
+        catch {
+            // 장소명은 네이버 지역 검색으로 보완하고 주소는 잘못된 장소로 대체하지 않습니다.
+        }
+    }
+    for (const document of documents) {
+        if (!isAddress && !document.place_name?.trim())
+            continue;
+        const latitude = Number(document.y);
+        const longitude = Number(document.x);
+        if (!validKoreanCoordinates(latitude, longitude) ||
+            !(isAddress
+                ? matchesAddress(keyword, document.address_name || '') ||
+                    matchesAddress(keyword, document.road_address_name || '')
+                : matches(keyword, `${document.place_name} ${document.address_name || ''} ${document.road_address_name || ''}`)))
+            continue;
+        return {
+            latitude,
+            longitude,
+            formattedAddress: document.road_address_name || document.address_name || null,
+        };
+    }
+    if (!isAddress && options.naverClientId && options.naverClientSecret) {
+        try {
+            const result = await searchNaverLocalPlaces({
+                ...options,
+                keyword,
+                timeoutMs: options.timeout ?? options.timeoutMs,
+            });
+            const place = result.places.find((item) => item.latitude !== null &&
+                item.longitude !== null &&
+                validKoreanCoordinates(item.latitude, item.longitude) &&
+                matches(keyword, `${item.name} ${item.address} ${item.roadAddress}`));
+            if (place)
+                return {
+                    latitude: place.latitude,
+                    longitude: place.longitude,
+                    formattedAddress: place.roadAddress || place.address || null,
+                };
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/utils/http.js

@@ -67,7 +67,7 @@ function parseRetryAfterDelayMs(response) {
     return null;
 }
 async function requestWithTimeout(url, options, readResponse) {
-    const { timeout = 10000, retries = 0, retryDelayMs = 250, retryStatusCodes = DEFAULT_RETRY_STATUS_CODES, retryUnsafeMethods = false, retryMethods = DEFAULT_RETRY_METHODS, onRetry, expectedStatus: _expectedStatus, ...restOptions } = options;
+    const { timeout = 10000, fetchImpl = fetch, retries = 0, retryDelayMs = 250, retryStatusCodes = DEFAULT_RETRY_STATUS_CODES, retryUnsafeMethods = false, retryMethods = DEFAULT_RETRY_METHODS, onRetry, expectedStatus: _expectedStatus, ...restOptions } = options;
     const maxAttempts = Math.max(1, Math.trunc(retries) + 1);
     const method = normalizeMethod(restOptions.method);
     const retryAllowed = canRetryMethod(method, retryMethods, retryUnsafeMethods);
@@ -77,7 +77,7 @@ async function requestWithTimeout(url, options, readResponse) {
         const started = Date.now();
         let responseStatus;
         try {
-            const response = await fetch(url, {
+            const response = await fetchImpl(url, {
                 ...restOptions,
                 signal: controller.signal,
             });