emergency-room-beds 0.2.0

package/README.md

@@ -0,0 +1,62 @@
+# emergency-room-beds
+
+Nearby Korean emergency-room lookup backed by E-Gen's public emergency-room search surface.
+
+## What it can and cannot report
+
+- It resolves a user-provided location to coordinates, then calls E-Gen's public nearby emergency-room list endpoint.
+- It reports distance, hospital category, address, phone, update time, and operation flags such as emergency-room operation and inpatient-bed operation.
+- Operation flags are tri-state: `true` for upstream `Y`, `false` for upstream `N`, and `null` when E-Gen omits or changes a flag value.
+- It does **not** claim exact real-time remaining bed counts. The public E-Gen nearby list exposes operation flags, not per-hospital remaining bed numbers.
+- For emergencies, call 119 or the hospital directly. Public E-Gen/Kakao data can lag, fail, or be incomplete and is not medical advice.
+
+## Public surfaces
+
+- NEMC monitoring entry point: `https://dw.nemc.or.kr/nemcMonitoring/mainmgr/Main.do`
+- E-Gen emergency-room search page: `https://www.e-gen.or.kr/egen/search_emergency_room.do`
+- E-Gen nearby emergency-room list endpoint: `https://www.e-gen.or.kr/egen/retrieve_emergency_room_list.do`
+- Kakao Map mobile search: `https://m.map.kakao.com/actions/searchView?q=<query>`
+- Kakao Map place panel JSON: `https://place-api.map.kakao.com/places/panel3/<confirmId>`
+
+## Usage
+
+```js
+const { searchNearbyEmergencyRoomsByLocationQuery } = require("emergency-room-beds");
+
+async function main() {
+  const result = await searchNearbyEmergencyRoomsByLocationQuery("광화문", {
+    limit: 3,
+    radius: 5
+  });
+
+  console.log(result.anchor);
+  console.log(result.items);
+  console.log(result.meta.bedCountLimitation);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
+```
+
+## Public API
+
+- `parseCoordinateQuery(locationQuery)`
+- `buildEmergencyRoomListRequest(options)`
+- `normalizeEmergencyRoomRows(payload, origin, options)`
+- `searchNearbyEmergencyRoomsByCoordinates(options)`
+- `searchNearbyEmergencyRoomsByLocationQuery(locationQuery, options)`
+
+## Result fields
+
+Each item includes:
+
+- `name`, `emergencyGrade`, `hospitalType`
+- `address`, `phone`, `latitude`, `longitude`, `distanceKm`
+- `bedStatus.emergencyRoomOperating`
+- `bedStatus.inpatientBedsOperating`
+- `bedStatus.traumaCenter`
+- `bedStatus.pediatricSpecialty`
+- `bedStatus.currentGeneralCareAvailable`
+- `updatedAt`, `sourceUrl`, `mapUrl`

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "emergency-room-beds",
+  "version": "0.2.0",
+  "description": "Public E-Gen nearby emergency room status lookup for Korean location queries",
+  "license": "MIT",
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NomaDamas/k-skill.git"
+  },
+  "keywords": [
+    "k-skill",
+    "korea",
+    "emergency-room",
+    "e-gen",
+    "hospital"
+  ],
+  "scripts": {
+    "lint": "node --check src/index.js && node --check src/parse.js && node --check test/index.test.js",
+    "test": "node --test"
+  }
+}

package/src/index.js

@@ -0,0 +1,275 @@
+const {
+  isValidLatitude,
+  isValidLongitude,
+  normalizeAnchorPanel,
+  normalizeEmergencyRoomRows,
+  parseCoordinateQuery,
+  parseSearchResultsHtml,
+  rankAnchorCandidates
+} = require("./parse");
+
+const SEARCH_VIEW_URL = "https://m.map.kakao.com/actions/searchView";
+const PLACE_PANEL_URL_BASE = "https://place-api.map.kakao.com/places/panel3";
+const EGEN_EMERGENCY_ROOM_LIST_URL = "https://www.e-gen.or.kr/egen/retrieve_emergency_room_list.do";
+const EGEN_REFERER_URL = "https://www.e-gen.or.kr/egen/search_emergency_room.do";
+const BED_COUNT_LIMITATION = "E-Gen nearby ER list exposes operation flags, not exact real-time remaining bed counts.";
+const DEFAULT_BROWSER_HEADERS = {
+  accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "accept-language": "ko,en-US;q=0.9,en;q=0.8",
+  "user-agent":
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+};
+const DEFAULT_PANEL_HEADERS = {
+  ...DEFAULT_BROWSER_HEADERS,
+  accept: "application/json, text/plain, */*",
+  appVersion: "6.6.0",
+  origin: "https://place.map.kakao.com",
+  pf: "PC",
+  referer: "https://place.map.kakao.com/"
+};
+const DEFAULT_JSON_HEADERS = {
+  accept: "application/json, text/javascript, */*; q=0.01",
+  "accept-language": "ko,en-US;q=0.9,en;q=0.8",
+  "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+  origin: "https://www.e-gen.or.kr",
+  referer: EGEN_REFERER_URL,
+  "user-agent": DEFAULT_BROWSER_HEADERS["user-agent"],
+  "x-requested-with": "XMLHttpRequest"
+};
+
+async function request(url, options = {}, responseType = "json") {
+  const fetchImpl = options.fetchImpl || global.fetch;
+
+  if (typeof fetchImpl !== "function") {
+    throw new Error("A fetch implementation is required.");
+  }
+
+  const response = await fetchImpl(url, {
+    method: options.method,
+    body: options.body,
+    headers: {
+      ...(options.headerSet || (responseType === "json" ? DEFAULT_JSON_HEADERS : DEFAULT_BROWSER_HEADERS)),
+      ...(options.headers || {})
+    },
+    signal: options.signal
+  });
+
+  if (!response.ok) {
+    const error = new Error(`Request failed with ${response.status} for ${url}`);
+    error.status = response.status;
+    error.url = url;
+    throw error;
+  }
+
+  return responseType === "json" ? response.json() : response.text();
+}
+
+function normalizeBoundedInteger(value, defaultValue, label, min, max) {
+  if (value === undefined || value === null || value === "") {
+    return defaultValue;
+  }
+
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < min || parsed > max) {
+    throw new Error(`${label} must be between ${min} and ${max}.`);
+  }
+
+  return parsed;
+}
+
+function normalizeCoordinate(value, label, isValid) {
+  const parsed = Number(value);
+
+  if (!isValid(parsed)) {
+    throw new Error(`${label} must be between ${label === "latitude" ? "-90 and 90" : "-180 and 180"}.`);
+  }
+
+  return parsed;
+}
+
+function normalizeCoordinates(options = {}) {
+  const latitude = Number(options.latitude ?? options.lat);
+  const longitude = Number(options.longitude ?? options.lon);
+
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+    throw new Error("latitude and longitude must be finite numbers.");
+  }
+
+  return {
+    latitude: normalizeCoordinate(latitude, "latitude", isValidLatitude),
+    longitude: normalizeCoordinate(longitude, "longitude", isValidLongitude)
+  };
+}
+
+function normalizeOrder(order) {
+  const value = String(order || "distance").trim();
+
+  if (!["distance", "accuracy"].includes(value)) {
+    throw new Error("order must be one of: distance, accuracy.");
+  }
+
+  return value;
+}
+
+function normalizeEmergencyGradeCodes(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry).trim()).filter(Boolean).join(",");
+  }
+
+  return String(value || "").trim();
+}
+
+function buildEmergencyRoomListRequest(options = {}) {
+  const { latitude, longitude } = normalizeCoordinates(options);
+
+  const radius = normalizeBoundedInteger(options.radius ?? options.maxDistanceKm, 3, "radius", 1, 50);
+  const currentPageNum = normalizeBoundedInteger(options.currentPageNum ?? options.pageNo, 1, "currentPageNum", 1, 1000);
+  const body = new URLSearchParams();
+  body.set("lat", String(latitude));
+  body.set("lon", String(longitude));
+  body.set("emoggrdcStr", normalizeEmergencyGradeCodes(options.emergencyGradeCodes ?? options.emoggrdcStr));
+  body.set("silson24", options.silson24 ? "Y" : "N");
+  body.set("emogdesc", String(options.hospitalName || options.emogdesc || "").trim());
+  body.set("radius", String(radius));
+  body.set("order", normalizeOrder(options.order));
+  body.set("currentPageNum", String(currentPageNum));
+
+  return {
+    url: options.apiBaseUrl || EGEN_EMERGENCY_ROOM_LIST_URL,
+    method: "POST",
+    body
+  };
+}
+
+async function fetchEmergencyRoomList(options = {}) {
+  const requestOptions = buildEmergencyRoomListRequest(options);
+
+  return request(
+    requestOptions.url,
+    {
+      ...options,
+      method: requestOptions.method,
+      body: requestOptions.body,
+      headerSet: DEFAULT_JSON_HEADERS
+    },
+    "json",
+  );
+}
+
+async function fetchSearchResults(query, options = {}) {
+  const url = new URL(SEARCH_VIEW_URL);
+  url.searchParams.set("q", String(query || "").trim());
+
+  return request(url.toString(), options, "text");
+}
+
+async function fetchPlacePanel(confirmId, options = {}) {
+  return request(`${PLACE_PANEL_URL_BASE}/${confirmId}`, { ...options, headerSet: DEFAULT_PANEL_HEADERS }, "json");
+}
+
+function isRecoverablePlacePanelError(error) {
+  const status = Number(error?.status);
+  return status === 404 || status === 410;
+}
+
+async function resolveAnchor(locationQuery, options = {}) {
+  const anchorSearchHtml = await fetchSearchResults(locationQuery, options);
+  const anchorCandidates = parseSearchResultsHtml(anchorSearchHtml);
+  const rankedCandidates = rankAnchorCandidates(locationQuery, anchorCandidates);
+
+  for (const candidate of rankedCandidates) {
+    let anchorPanel;
+    try {
+      anchorPanel = await fetchPlacePanel(candidate.id, options);
+    } catch (error) {
+      if (isRecoverablePlacePanelError(error)) {
+        continue;
+      }
+      throw error;
+    }
+
+    const anchor = normalizeAnchorPanel(anchorPanel, candidate);
+    if (Number.isFinite(anchor.latitude) && Number.isFinite(anchor.longitude)) {
+      return { anchor, anchorCandidates: rankedCandidates };
+    }
+  }
+
+  throw new Error(`No usable Kakao Map place panel was available for ${locationQuery}.`);
+}
+
+function buildMeta(payload, options, total) {
+  const limit = normalizeBoundedInteger(options.limit, 5, "limit", 1, 50);
+  const radius = normalizeBoundedInteger(options.radius ?? options.maxDistanceKm, 3, "radius", 1, 50);
+
+  return {
+    total,
+    upstreamTotal: payload?.paging?.totalCount ?? null,
+    limit,
+    radius,
+    source: "e-gen",
+    sourceUrl: EGEN_REFERER_URL,
+    dashboardUrl: "https://dw.nemc.or.kr/nemcMonitoring/mainmgr/Main.do",
+    bedCountLimitation: BED_COUNT_LIMITATION
+  };
+}
+
+async function searchNearbyEmergencyRoomsByCoordinates(options = {}) {
+  const { latitude, longitude } = normalizeCoordinates(options);
+
+  const limit = normalizeBoundedInteger(options.limit, 5, "limit", 1, 50);
+  const payload = await fetchEmergencyRoomList({ ...options, latitude, longitude });
+  const allItems = normalizeEmergencyRoomRows(payload, { latitude, longitude }, options);
+
+  return {
+    anchor: {
+      name: options.anchorName || "입력 좌표",
+      address: options.anchorAddress || null,
+      latitude,
+      longitude
+    },
+    items: allItems.slice(0, limit),
+    meta: buildMeta(payload, { ...options, limit }, allItems.length)
+  };
+}
+
+async function searchNearbyEmergencyRoomsByLocationQuery(locationQuery, options = {}) {
+  const coordinateQuery = parseCoordinateQuery(locationQuery);
+
+  if (coordinateQuery) {
+    return searchNearbyEmergencyRoomsByCoordinates({
+      ...options,
+      ...coordinateQuery,
+      anchorName: "입력 좌표"
+    });
+  }
+
+  const { anchor, anchorCandidates } = await resolveAnchor(locationQuery, options);
+  const result = await searchNearbyEmergencyRoomsByCoordinates({
+    ...options,
+    latitude: anchor.latitude,
+    longitude: anchor.longitude,
+    anchorName: anchor.name,
+    anchorAddress: anchor.address
+  });
+
+  return {
+    ...result,
+    anchor,
+    meta: {
+      ...result.meta,
+      anchorCandidates: anchorCandidates.length
+    }
+  };
+}
+
+module.exports = {
+  BED_COUNT_LIMITATION,
+  DEFAULT_JSON_HEADERS,
+  EGEN_EMERGENCY_ROOM_LIST_URL,
+  buildEmergencyRoomListRequest,
+  fetchEmergencyRoomList,
+  normalizeEmergencyRoomRows,
+  parseCoordinateQuery,
+  searchNearbyEmergencyRoomsByCoordinates,
+  searchNearbyEmergencyRoomsByLocationQuery
+};

package/src/parse.js

@@ -0,0 +1,295 @@
+const SEARCH_ITEM_PATTERN = /<li\s+class="search_item\s+base"([\s\S]*?)<\/li>/giu;
+const TAG_PATTERN = /<[^>]+>/g;
+const NON_WORD_PATTERN = /[^\p{L}\p{N}]+/gu;
+
+function decodeHtml(value) {
+  return String(value || "")
+    .replace(/&amp;/g, "&")
+    .replace(/&#39;/g, "'")
+    .replace(/&quot;/g, '"')
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">");
+}
+
+function stripTags(value) {
+  return decodeHtml(String(value || "").replace(TAG_PATTERN, " "))
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizeText(value) {
+  return String(value || "")
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(NON_WORD_PATTERN, "");
+}
+
+function extractAttribute(fragment, name) {
+  const match = fragment.match(new RegExp(`${name}="([^"]*)"`, "iu"));
+  return match ? decodeHtml(match[1]).trim() : "";
+}
+
+function extractInnerText(fragment, className) {
+  const match = fragment.match(
+    new RegExp(`<[^>]+class="[^"]*${className}[^"]*"[^>]*>([\\s\\S]*?)<\\/[^>]+>`, "iu"),
+  );
+
+  return match ? stripTags(match[1]) : "";
+}
+
+function parseSearchResultsHtml(html) {
+  const items = [];
+  let match;
+
+  while ((match = SEARCH_ITEM_PATTERN.exec(String(html || ""))) !== null) {
+    const fragment = match[1];
+    const id = extractAttribute(fragment, "data-id");
+    const name = extractAttribute(fragment, "data-title") || extractInnerText(fragment, "tit_g");
+
+    if (!id || !name) {
+      continue;
+    }
+
+    const addressMatches = [...fragment.matchAll(/<span class="txt_g">([\s\S]*?)<\/span>/giu)]
+      .map((entry) => stripTags(entry[1]))
+      .filter(Boolean);
+
+    items.push({
+      id,
+      name,
+      category: extractInnerText(fragment, "txt_ginfo"),
+      address: addressMatches.at(-1) || "",
+      phone: extractAttribute(fragment, "data-phone") || extractInnerText(fragment, "num_phone") || null
+    });
+  }
+
+  return items;
+}
+
+function scoreAnchorCandidate(query, item) {
+  const normalizedQuery = normalizeText(query);
+  const normalizedName = normalizeText(item.name);
+  const normalizedAddress = normalizeText(item.address);
+  let score = 0;
+
+  if (!normalizedQuery) {
+    return score;
+  }
+
+  if (normalizedName === normalizedQuery) {
+    score += 1000;
+  }
+  if (normalizedName.startsWith(normalizedQuery)) {
+    score += 800;
+  }
+  if (normalizedName.includes(normalizedQuery)) {
+    score += 600;
+  }
+  if (normalizedAddress.includes(normalizedQuery)) {
+    score += 120;
+  }
+
+  return score;
+}
+
+function rankAnchorCandidates(query, items) {
+  return [...(items || [])].sort((left, right) => {
+    const scoreDelta = scoreAnchorCandidate(query, right) - scoreAnchorCandidate(query, left);
+
+    if (scoreDelta !== 0) {
+      return scoreDelta;
+    }
+
+    return left.name.localeCompare(right.name, "ko");
+  });
+}
+
+function normalizeAnchorPanel(panel, searchItem = {}) {
+  const summary = panel.summary || {};
+
+  return {
+    id: String(summary.confirm_id || searchItem.id || ""),
+    name: summary.name || searchItem.name || "",
+    category: summary.category?.name3 || summary.category?.name2 || searchItem.category || "",
+    address: summary.address?.disp || searchItem.address || "",
+    phone: summary.phone_numbers?.[0]?.tel || searchItem.phone || null,
+    latitude: toNumber(summary.point?.lat),
+    longitude: toNumber(summary.point?.lon),
+    sourceUrl: summary.confirm_id ? `https://place.map.kakao.com/${summary.confirm_id}` : null
+  };
+}
+
+function parseCoordinateQuery(locationQuery) {
+  const match = String(locationQuery || "")
+    .trim()
+    .match(/^(-?\d+(?:\.\d+)?)\s*[,/ ]\s*(-?\d+(?:\.\d+)?)$/);
+
+  if (!match) {
+    return null;
+  }
+
+  const latitude = Number(match[1]);
+  const longitude = Number(match[2]);
+
+  if (!isValidCoordinatePair(latitude, longitude)) {
+    return null;
+  }
+
+  return { latitude, longitude };
+}
+
+function toNumber(value) {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
+
+  const parsed = Number(String(value).replace(/,/g, ""));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function isValidLatitude(value) {
+  return Number.isFinite(value) && value >= -90 && value <= 90;
+}
+
+function isValidLongitude(value) {
+  return Number.isFinite(value) && value >= -180 && value <= 180;
+}
+
+function isValidCoordinatePair(latitude, longitude) {
+  return isValidLatitude(latitude) && isValidLongitude(longitude);
+}
+
+function toBooleanYesNo(value) {
+  const normalized = String(value ?? "").trim().toUpperCase();
+
+  if (normalized === "Y") {
+    return true;
+  }
+
+  if (normalized === "N") {
+    return false;
+  }
+
+  return null;
+}
+
+function buildMapUrl(name, latitude, longitude) {
+  return `https://map.kakao.com/link/map/${encodeURIComponent(name)},${latitude},${longitude}`;
+}
+
+function parseEgenTimestamp(value) {
+  const text = String(value || "").trim();
+  const match = text.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/);
+
+  if (!match) {
+    return null;
+  }
+
+  return `${match[1]}-${match[2]}-${match[3]}T${match[4]}:${match[5]}:${match[6]}+09:00`;
+}
+
+function haversineDistanceMeters(latitudeA, longitudeA, latitudeB, longitudeB) {
+  const earthRadiusMeters = 6371008.8;
+  const toRadians = (value) => (value * Math.PI) / 180;
+  const deltaLatitude = toRadians(latitudeB - latitudeA);
+  const deltaLongitude = toRadians(longitudeB - longitudeA);
+  const originLatitude = toRadians(latitudeA);
+  const targetLatitude = toRadians(latitudeB);
+
+  const value =
+    Math.sin(deltaLatitude / 2) ** 2 +
+    Math.cos(originLatitude) * Math.cos(targetLatitude) * Math.sin(deltaLongitude / 2) ** 2;
+
+  return 2 * earthRadiusMeters * Math.atan2(Math.sqrt(value), Math.sqrt(1 - value));
+}
+
+function getEmergencyRoomRows(payload) {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+
+  if (Array.isArray(payload?.list)) {
+    return payload.list;
+  }
+
+  throw new Error("Unexpected E-Gen emergency room payload shape.");
+}
+
+function normalizeEmergencyRoomRows(payload, origin, options = {}) {
+  const latitude = Number(origin?.latitude);
+  const longitude = Number(origin?.longitude);
+  const radius = Number.isFinite(Number(options.radius ?? options.maxDistanceKm)) ? Number(options.radius ?? options.maxDistanceKm) : null;
+
+  if (!isValidCoordinatePair(latitude, longitude)) {
+    throw new Error("normalizeEmergencyRoomRows requires valid origin coordinates.");
+  }
+
+  return getEmergencyRoomRows(payload)
+    .map((row) => {
+      const itemLatitude = toNumber(row.LAT ?? row.lat);
+      const itemLongitude = toNumber(row.LON ?? row.lon);
+
+      if (!isValidCoordinatePair(itemLatitude, itemLongitude)) {
+        return null;
+      }
+
+      const distanceKm = toNumber(row.DISTANCE2 ?? row.DISTANCE) ?? haversineDistanceMeters(latitude, longitude, itemLatitude, itemLongitude) / 1000;
+      const name = String(row.TITLE || row.name || "").trim();
+
+      if (!name) {
+        return null;
+      }
+
+      return {
+        id: String(row.EMOGCODE || row.id || ""),
+        name,
+        emergencyGrade: row.CATEGORY1 || null,
+        hospitalType: row.CATEGORY2 || null,
+        address: row.ADDRROAD || row.ADDRLAGE || null,
+        phone: row.TEL || null,
+        latitude: itemLatitude,
+        longitude: itemLongitude,
+        distanceKm: Math.round(distanceKm * 1000) / 1000,
+        bedStatus: {
+          emergencyRoomOperating: toBooleanYesNo(row.EMOGERYN),
+          inpatientBedsOperating: toBooleanYesNo(row.EMOGPRYN),
+          traumaCenter: toBooleanYesNo(row.EMOGTRYN),
+          pediatricSpecialty: toBooleanYesNo(row.CHILD_SPCLTY_AT),
+          currentGeneralCareAvailable: toBooleanYesNo(row.OPERATIONYN),
+          pediatricNightCare: toBooleanYesNo(row.NIGHTCAREYN),
+          holidayOpen: toBooleanYesNo(row.HOLIDAYYN),
+          silson24Linked: toBooleanYesNo(row.SILSON24_CHK)
+        },
+        schedules: {
+          monday: row.MONDAY || null,
+          tuesday: row.TUESDAY || null,
+          wednesday: row.WEDNESDAY || null,
+          thursday: row.THURSDAY || null,
+          friday: row.FRIDAY || null,
+          saturday: row.SATURDAY || null,
+          sunday: row.SUNDAY || null,
+          holiday: row.HOLIDAY || null,
+          note: row.OPN_BIGO || null
+        },
+        updatedAt: parseEgenTimestamp(row.EMOGUPDT),
+        sourceUrl: "https://www.e-gen.or.kr/egen/search_emergency_room.do",
+        mapUrl: buildMapUrl(name, itemLatitude, itemLongitude)
+      };
+    })
+    .filter(Boolean)
+    .filter((item) => radius === null || item.distanceKm <= radius)
+    .sort((left, right) => left.distanceKm - right.distanceKm || left.name.localeCompare(right.name, "ko"));
+}
+
+module.exports = {
+  buildMapUrl,
+  isValidCoordinatePair,
+  isValidLatitude,
+  isValidLongitude,
+  normalizeAnchorPanel,
+  normalizeEmergencyRoomRows,
+  parseCoordinateQuery,
+  parseEgenTimestamp,
+  parseSearchResultsHtml,
+  rankAnchorCandidates
+};