daiso 1.0.4 → 1.0.5

package/dist/services/lottemart/clientTypes.js

@@ -0,0 +1,4 @@
+/**
+ * 롯데마트 클라이언트 입력 타입
+ */
+export {};

package/dist/services/lottemart/config.js

@@ -0,0 +1,4 @@
+/**
+ * 롯데마트 서비스 공통 설정
+ */
+export const DEFAULT_LOTTEMART_TIMEOUT_MS = 45000;

package/dist/services/lottemart/debug.js

@@ -0,0 +1,92 @@
+/**
+ * 롯데마트 업스트림 단독 진단
+ */
+import { LOTTEMART_API } from './api.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from './config.js';
+import { probeLotteMartRequest } from './session.js';
+import { normalizeArea } from './storeSearch.js';
+function resolveArea(area) {
+    const normalized = normalizeArea(area || '경기');
+    return normalized || '경기';
+}
+export function buildLotteMartDebugRequest(params) {
+    const target = params.target;
+    const area = resolveArea(params.area);
+    switch (target) {
+        case 'market-options': {
+            const endpoint = new URL(LOTTEMART_API.MARKET_OPTIONS_PATH, LOTTEMART_API.BASE_URL);
+            endpoint.searchParams.set('p_area', area);
+            endpoint.searchParams.set('p_type', params.type || '1');
+            if ((params.storeCode || '').trim().length > 0) {
+                endpoint.searchParams.set('p_werks', params.storeCode.trim());
+            }
+            return {
+                target,
+                method: 'GET',
+                url: endpoint.toString(),
+                bodyText: null,
+            };
+        }
+        case 'stores':
+            return {
+                target,
+                method: 'POST',
+                url: new URL(LOTTEMART_API.STORE_SEARCH_PATH, LOTTEMART_API.BASE_URL).toString(),
+                bodyText: new URLSearchParams({
+                    m_area: area,
+                    ...(params.storeCode ? { m_market: params.storeCode.trim() } : {}),
+                    ...(params.keyword ? { m_schWord: params.keyword.trim() } : {}),
+                }).toString(),
+            };
+        case 'products':
+            return {
+                target,
+                method: 'POST',
+                url: new URL(LOTTEMART_API.PRODUCT_SEARCH_PATH, LOTTEMART_API.BASE_URL).toString(),
+                bodyText: new URLSearchParams({
+                    p_area: area,
+                    p_market: (params.storeCode || '2415').trim(),
+                    p_schWord: (params.keyword || '핫식스').trim(),
+                }).toString(),
+            };
+        case 'product-page': {
+            const endpoint = new URL(LOTTEMART_API.PRODUCT_PAGE_PATH, LOTTEMART_API.BASE_URL);
+            endpoint.searchParams.set('p_market', (params.storeCode || '2415').trim());
+            endpoint.searchParams.set('p_schWord', (params.keyword || '핫식스').trim());
+            endpoint.searchParams.set('page', String(Math.max(params.page || 2, 1)));
+            return {
+                target,
+                method: 'GET',
+                url: endpoint.toString(),
+                bodyText: null,
+            };
+        }
+    }
+}
+export async function probeLotteMartUpstream(params) {
+    const request = buildLotteMartDebugRequest(params);
+    const timeout = params.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS;
+    const init = {
+        method: request.method,
+        headers: request.method === 'POST'
+            ? {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            }
+            : {
+                Accept: 'text/html, */*; q=0.01',
+                'X-Requested-With': 'XMLHttpRequest',
+            },
+        body: request.bodyText || undefined,
+    };
+    return {
+        request: {
+            target: request.target,
+            method: request.method,
+            url: request.url,
+            bodyText: request.bodyText,
+            timeout,
+            hasZyteApiKey: Boolean(params.zyteApiKey),
+        },
+        attempts: await probeLotteMartRequest(request.url, init, timeout, '', params.zyteApiKey),
+    };
+}

package/dist/services/lottemart/geocode.js

@@ -0,0 +1,49 @@
+/**
+ * 롯데마트 매장 주소 지오코딩
+ */
+import { fetchJson } from '../../utils/http.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from './config.js';
+const GEOCODE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const geocodeCache = new Map();
+export async function geocodeLotteMartAddress(address, options = {}) {
+    const keyword = address.trim();
+    if (keyword.length === 0) {
+        return null;
+    }
+    const cached = geocodeCache.get(keyword);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
+    const apiKey = (options.googleMapsApiKey || '').trim();
+    if (apiKey.length === 0) {
+        return null;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    endpoint.searchParams.set('address', keyword);
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout: options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS,
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (body.status !== 'OK') {
+        geocodeCache.set(keyword, {
+            expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+            value: null,
+        });
+        return null;
+    }
+    const latitude = body.results?.[0]?.geometry?.location?.lat;
+    const longitude = body.results?.[0]?.geometry?.location?.lng;
+    const value = typeof latitude === 'number' && typeof longitude === 'number' ? { latitude, longitude } : null;
+    geocodeCache.set(keyword, {
+        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
+export function __testOnlyClearLotteMartGeocodeCache() {
+    geocodeCache.clear();
+}

package/dist/services/lottemart/index.js

@@ -0,0 +1,30 @@
+/**
+ * 롯데마트 서비스 프로바이더
+ */
+import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
+import { createSearchProductsTool } from './tools/searchProducts.js';
+const LOTTEMART_METADATA = {
+    id: 'lottemart',
+    name: '롯데마트',
+    version: '1.0.0',
+    description: '롯데마트 계열 매장 탐색 및 매장별 상품 검색 서비스',
+};
+class LotteMartService {
+    googleMapsApiKey;
+    zyteApiKey;
+    metadata = LOTTEMART_METADATA;
+    constructor(googleMapsApiKey, zyteApiKey) {
+        this.googleMapsApiKey = googleMapsApiKey;
+        this.zyteApiKey = zyteApiKey;
+    }
+    getTools() {
+        return [
+            createFindNearbyStoresTool(this.googleMapsApiKey, this.zyteApiKey),
+            createSearchProductsTool(this.zyteApiKey),
+        ];
+    }
+}
+export function createLotteMartService(options = {}) {
+    return new LotteMartService(options.googleMapsApiKey, options.zyteApiKey);
+}
+export * from './types.js';

package/dist/services/lottemart/keyword.js

@@ -0,0 +1,29 @@
+/**
+ * 롯데마트 매장 검색 키워드 보정
+ */
+export function buildLotteMartKeywordVariants(rawKeyword) {
+    const base = rawKeyword.trim();
+    if (!base) {
+        return [];
+    }
+    const compact = base.replace(/\s+/g, '');
+    const withoutNoise = compact.replace(/(롯데마트|근처|주변)/g, '');
+    const tokens = base
+        .split(/\s+/)
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0)
+        .filter((value) => !['롯데마트', '근처', '주변'].includes(value));
+    const normalizedTokens = tokens
+        .map((value) => value.replace(/역$/g, '').trim())
+        .filter((value) => value.length > 0);
+    const primaryToken = normalizedTokens[0] || tokens[0] || '';
+    const candidates = [
+        base,
+        compact,
+        withoutNoise,
+        primaryToken,
+        ...(tokens.length <= 1 ? tokens : []),
+        ...(normalizedTokens.length <= 1 ? normalizedTokens : []),
+    ];
+    return [...new Set(candidates.map((value) => value.trim()).filter((value) => value.length > 0))];
+}

package/dist/services/lottemart/parser.js

@@ -0,0 +1,185 @@
+/**
+ * 롯데마트 HTML 파싱 유틸리티
+ */
+import { buildLotteMartKeywordVariants } from './keyword.js';
+export function detectBrandVariant(storeName) {
+    if (storeName.startsWith('토이저러스')) {
+        return 'toysrus';
+    }
+    if (storeName.startsWith('맥스')) {
+        return 'max';
+    }
+    if (storeName.startsWith('보틀벙커')) {
+        return 'bottlebunker';
+    }
+    if (storeName.startsWith('Mealguru')) {
+        return 'mealguru';
+    }
+    if (storeName.startsWith('그랑그로서리')) {
+        return 'grandgrocery';
+    }
+    return 'lottemart';
+}
+function decodeHtmlEntities(value) {
+    return value
+        .replace(/ /gi, ' ')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        .replace(/&#x2F;/gi, '/')
+        .replace(/&amp;/gi, '&');
+}
+function stripHtmlComments(value) {
+    let sanitized = '';
+    let index = 0;
+    while (index < value.length) {
+        if (value.startsWith('<!--', index)) {
+            const commentEnd = value.indexOf('-->', index + 4);
+            if (commentEnd < 0) {
+                break;
+            }
+            index = commentEnd + 3;
+            continue;
+        }
+        sanitized += value[index];
+        index += 1;
+    }
+    return sanitized.replaceAll('<!--', '').replaceAll('-->', '');
+}
+function stripTags(value) {
+    return stripHtmlComments(value).replace(/<br\s*\/?>/gi, '\n').replace(/<[^>]+>/g, ' ');
+}
+function normalizeWhitespace(value) {
+    return decodeHtmlEntities(stripTags(value)).replace(/\s+/g, ' ').trim();
+}
+export function normalizeHtml(html) {
+    const trimmed = html.trim();
+    const htmlStart = trimmed.search(/<(?:!doctype|html|option|li|ul|section)\b/i);
+    return htmlStart >= 0 ? trimmed.slice(htmlStart) : trimmed;
+}
+function toNumber(value) {
+    const parsed = Number.parseFloat(value.replace(/[^\d.-]/g, ''));
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+export function calculateDistanceM(lat1, lng1, lat2, lng2) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLng = toRad(lng2 - lng1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return Math.round(6371000 * c);
+}
+function splitTopLevelBlocks(html, markerClass) {
+    const pattern = new RegExp(`<li>\\s*<div class="${markerClass}">`, 'g');
+    const normalized = html.replace(/\r/g, '');
+    const indexes = Array.from(normalized.matchAll(pattern)).map((match) => match.index || 0);
+    return indexes.map((start, index) => normalized.slice(start, indexes[index + 1] || normalized.length));
+}
+function extractFirstMatch(pattern, value) {
+    return value.match(pattern)?.[1]?.trim() || '';
+}
+export function parseMarketOptions(area, html) {
+    return Array.from(normalizeHtml(html).matchAll(/<option value="([^"]*)"[^>]*>([^<]*)<\/option>/g))
+        .map((match) => ({
+        area,
+        storeCode: (match[1] || '').trim(),
+        storeName: normalizeWhitespace(match[2] || ''),
+    }))
+        .filter((item) => item.storeCode.length > 0 && item.storeName.length > 0)
+        .map((item) => ({
+        ...item,
+        brandVariant: detectBrandVariant(item.storeName),
+    }));
+}
+export function parseStores(area, html) {
+    return splitTopLevelBlocks(normalizeHtml(html), 'shop-tit')
+        .map((block) => {
+        const storeName = normalizeWhitespace(extractFirstMatch(/<div class="shop-tit">([\s\S]*?)<\/div>/, block));
+        const detailUrl = extractFirstMatch(/<a class="link" href="([^"]+)"/, block);
+        const storeCode = extractFirstMatch(/werks=([^'"]+)/, block) || extractFirstMatch(/goClick\('([^']+)'\)/, block);
+        return {
+            area,
+            storeCode,
+            storeName,
+            brandVariant: detectBrandVariant(storeName),
+            address: normalizeWhitespace(extractFirstMatch(/주소\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            phone: normalizeWhitespace(extractFirstMatch(/상담전화\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            openTime: normalizeWhitespace(extractFirstMatch(/영업시간\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            closedDays: normalizeWhitespace(extractFirstMatch(/휴점일\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            parkingType: normalizeWhitespace(extractFirstMatch(/주차정보\s*:\s*([^<]*)<\/span>/, block)),
+            parkingDetails: normalizeWhitespace(extractFirstMatch(/<div class="park-info">([\s\S]*?)<\/div>/, block)),
+            detailUrl: detailUrl.startsWith('.') ? `/mobiledowa/market/${detailUrl.replace(/^\.\//, '')}` : detailUrl,
+            latitude: 0,
+            longitude: 0,
+            distanceM: null,
+        };
+    })
+        .filter((store) => store.storeCode.length > 0 && store.storeName.length > 0);
+}
+export function parseProducts(area, storeCode, storeName, keyword, html) {
+    return splitTopLevelBlocks(normalizeHtml(html), 'prod-box')
+        .map((block) => {
+        const rawSpec = extractFirstMatch(/<div class="prod-count">([\s\S]*?)<\/div>/, block);
+        return {
+            area,
+            storeCode,
+            storeName,
+            keyword,
+            productName: normalizeWhitespace(extractFirstMatch(/<div class="prod-name">([\s\S]*?)<\/div>/, block)) ||
+                normalizeWhitespace(extractFirstMatch(/<div class="layer-head">([\s\S]*?)<\/div>/, block)),
+            barcode: normalizeWhitespace(extractFirstMatch(/<!--\s*([^>]+?)\s*-->/, rawSpec)),
+            spec: normalizeWhitespace(stripHtmlComments(rawSpec)),
+            manufacturer: normalizeWhitespace(extractFirstMatch(/제조사\s*:\s*<\/th>\s*<td>([\s\S]*?)<\/td>/, block)),
+            price: toNumber(extractFirstMatch(/가격\s*:\s*<\/th>\s*<td>([\s\S]*?)<\/td>/, block)),
+            stockQuantity: toNumber(extractFirstMatch(/재고\s*:\s*<\/th>\s*<td>([\s\S]*?)<\/td>/, block)),
+        };
+    })
+        .filter((product) => product.productName.length > 0);
+}
+export function parseProductSummary(html) {
+    const normalized = normalizeHtml(html);
+    const totalCount = toNumber(extractFirstMatch(/검색결과\s*:\s*<span>([\d,]+)<\/span>건/, normalized));
+    const totalPages = toNumber(extractFirstMatch(/var\s+totalPage\s*=\s*"(\d+)"/, normalized));
+    return {
+        totalCount,
+        totalPages: totalPages > 0 ? totalPages : 1,
+    };
+}
+export function dedupeProducts(products) {
+    return Array.from(new Map(products.map((product) => [
+        [product.productName, product.spec, product.manufacturer, product.price, product.stockQuantity].join('|'),
+        product,
+    ])).values());
+}
+export function matchesKeyword(store, keyword) {
+    const variants = buildLotteMartKeywordVariants(keyword).map((value) => value.toLowerCase());
+    if (variants.length === 0) {
+        return true;
+    }
+    const haystacks = [store.storeName, store.address, store.phone]
+        .map((value) => value.toLowerCase().replace(/\s+/g, ''))
+        .filter((value) => value.length > 0);
+    return variants.some((variant) => {
+        const normalizedVariant = variant.replace(/\s+/g, '');
+        return haystacks.some((value) => value.includes(normalizedVariant));
+    });
+}
+export function matchesBrandVariant(store, brandVariant) {
+    const normalized = (brandVariant || '').trim().toLowerCase();
+    return normalized.length === 0 ? true : store.brandVariant === normalized;
+}
+export function sortStores(stores) {
+    return [...stores].sort((a, b) => {
+        const distanceDelta = (a.distanceM ?? Number.MAX_SAFE_INTEGER) - (b.distanceM ?? Number.MAX_SAFE_INTEGER);
+        if (distanceDelta !== 0) {
+            return distanceDelta;
+        }
+        const areaDelta = a.area.localeCompare(b.area, 'ko');
+        if (areaDelta !== 0) {
+            return areaDelta;
+        }
+        return a.storeName.localeCompare(b.storeName, 'ko');
+    });
+}