thaizip 0.5.1 → 0.7.2

package/dist/index.js

@@ -1,8 +1,6 @@
-import { useState, useRef, useCallback, useEffect } from 'react';
-
 // src/core/normalizer.ts
-var TONE_MARKS = /[\u0E48-\u0E4B\u0E47\u0E4C]/g;
-var ADDRESS_PREFIXES = /^(จังหวัด|อำเภอ|ตำบล|แขวง|เขต)/;
+var TONE_MARKS = /[่-๋็์]/g;
+var ADDRESS_PREFIXES = /^(จังหวัด|อำเภอ|ตำบล|แขวง|เขต|จ\.|อ\.|ต\.|ข\.)/;
 function normalizeThaiAddressText(input) {
   if (!input) return "";
   let text = input.trim();
@@ -30,7 +28,56 @@ function extractTrigramsNormalized(text) {
 }
 
 // src/core/indexer.ts
-function buildThaiAddressIndex(data) {
+function typeErr(table, id, field, expected, value) {
+  return new TypeError(`[thaizip] ${table} ${id}: expected ${expected} for ${field}, got ${typeof value}`);
+}
+function validateRawData(data) {
+  const { provinces, amphures, tambons } = data;
+  for (let i = 0; i < provinces.length; i++) {
+    const p = provinces[i];
+    if (typeof p.id !== "number") throw typeErr("province", p.id, "id", "number", p.id);
+    if (typeof p.name_th !== "string") throw typeErr("province", p.id, "name_th", "string", p.name_th);
+    if (typeof p.name_en !== "string") throw typeErr("province", p.id, "name_en", "string", p.name_en);
+  }
+  for (let i = 0; i < amphures.length; i++) {
+    const a = amphures[i];
+    if (typeof a.id !== "number") throw typeErr("amphure", a.id, "id", "number", a.id);
+    if (typeof a.name_th !== "string") throw typeErr("amphure", a.id, "name_th", "string", a.name_th);
+    if (typeof a.name_en !== "string") throw typeErr("amphure", a.id, "name_en", "string", a.name_en);
+    if (typeof a.province_id !== "number") throw typeErr("amphure", a.id, "province_id", "number", a.province_id);
+  }
+  for (let i = 0; i < tambons.length; i++) {
+    const t = tambons[i];
+    if (typeof t.id !== "number") throw typeErr("tambon", t.id, "id", "number", t.id);
+    if (typeof t.name_th !== "string") throw typeErr("tambon", t.id, "name_th", "string", t.name_th);
+    if (typeof t.name_en !== "string") throw typeErr("tambon", t.id, "name_en", "string", t.name_en);
+    const zipType = typeof t.zip_code;
+    if (zipType !== "string" && zipType !== "number") {
+      throw typeErr("tambon", t.id, "zip_code", "string or number", t.zip_code);
+    }
+    if (typeof t.amphure_id !== "number") throw typeErr("tambon", t.id, "amphure_id", "number", t.amphure_id);
+  }
+}
+function addTrigrams(map, trigrams, idx) {
+  for (const trigram of trigrams) {
+    let set = map.get(trigram);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      map.set(trigram, set);
+    }
+    set.add(idx);
+  }
+}
+function combinedTrigrams(nameTh, nameEn) {
+  const s = /* @__PURE__ */ new Set();
+  for (const t of extractTrigrams(nameTh)) s.add(t);
+  for (const t of extractTrigrams(nameEn)) s.add(t);
+  return s;
+}
+function buildThaiAddressIndex(data, options) {
+  if (options?.validate !== false) {
+    validateRawData(data);
+  }
   const { provinces, amphures, tambons } = data;
   const provMap = new Map(
     provinces.filter((p) => !p.deleted_at).map((p) => [p.id, p])
@@ -38,20 +85,33 @@ function buildThaiAddressIndex(data) {
   const ampMap = new Map(
     amphures.filter((a) => !a.deleted_at).map((a) => [a.id, a])
   );
+  const provTrigrams = /* @__PURE__ */ new Map();
+  for (const [id, prov] of provMap) {
+    provTrigrams.set(id, combinedTrigrams(prov.name_th, prov.name_en));
+  }
+  const ampTrigrams = /* @__PURE__ */ new Map();
+  for (const [id, amp] of ampMap) {
+    ampTrigrams.set(id, combinedTrigrams(amp.name_th, amp.name_en));
+  }
   const records = [];
   const map = /* @__PURE__ */ new Map();
   const zipIndex = /* @__PURE__ */ new Map();
+  const normTambon = [];
+  const normTambonEn = [];
+  const byProvince = /* @__PURE__ */ new Map();
+  const byAmphure = /* @__PURE__ */ new Map();
   for (const tambon of tambons) {
     if (tambon.deleted_at) continue;
     const amphure = ampMap.get(tambon.amphure_id);
     if (!amphure) {
-      console.warn(
-        `[thaizip] skipping tambon id=${tambon.id} (${tambon.name_th}): amphure_id=${tambon.amphure_id} not found or deleted`
-      );
+      if (options?.onSkip) options.onSkip(tambon);
       continue;
     }
     const province = provMap.get(amphure.province_id);
-    if (!province) continue;
+    if (!province) {
+      if (options?.onSkip) options.onSkip(tambon);
+      continue;
+    }
     const record = {
       provinceId: province.id,
       provinceNameTh: province.name_th,
@@ -69,56 +129,195 @@ function buildThaiAddressIndex(data) {
     const existing = zipIndex.get(record.zipCode);
     if (existing) existing.push(idx);
     else zipIndex.set(record.zipCode, [idx]);
-    const fields = [
-      record.tambonNameTh,
-      record.tambonNameEn,
-      record.amphureNameTh,
-      record.amphureNameEn,
-      record.provinceNameTh,
-      record.provinceNameEn,
-      record.zipCode
-    ];
-    for (const field of fields) {
-      for (const trigram of extractTrigrams(field)) {
-        let set = map.get(trigram);
-        if (!set) {
-          set = /* @__PURE__ */ new Set();
-          map.set(trigram, set);
-        }
-        set.add(idx);
-      }
-    }
+    const provList = byProvince.get(province.id);
+    if (provList) provList.push(idx);
+    else byProvince.set(province.id, [idx]);
+    const ampList = byAmphure.get(amphure.id);
+    if (ampList) ampList.push(idx);
+    else byAmphure.set(amphure.id, [idx]);
+    const normTh = normalizeThaiAddressText(record.tambonNameTh);
+    normTambon.push(normTh);
+    addTrigrams(map, extractTrigramsNormalized(normTh), idx);
+    const normEn = normalizeThaiAddressText(record.tambonNameEn);
+    normTambonEn.push(normEn);
+    addTrigrams(map, extractTrigramsNormalized(normEn), idx);
+    addTrigrams(map, extractTrigrams(record.zipCode), idx);
+    addTrigrams(map, provTrigrams.get(province.id), idx);
+    addTrigrams(map, ampTrigrams.get(amphure.id), idx);
   }
-  return { map, records, zipIndex };
+  return { map, records, zipIndex, normTambon, normTambonEn, byProvince, byAmphure };
+}
+
+// src/core/romanize.ts
+var ALIASES = /* @__PURE__ */ new Map([
+  // --- Bangkok khet (districts) — concatenated ("no space") forms ---------
+  ["phranakhon", "phra nakhon"],
+  ["nongchok", "nong chok"],
+  ["bangrak", "bang rak"],
+  ["bangkhen", "bang khen"],
+  ["bangkapi", "bang kapi"],
+  ["pathumwan", "pathum wan"],
+  ["patumwan", "pathum wan"],
+  ["pomprap", "pom prap sattru phai"],
+  ["phrakhanong", "phra khanong"],
+  ["minburi", "min buri"],
+  ["latkrabang", "lat krabang"],
+  ["ladkrabang", "lat krabang"],
+  ["yannawa", "yan nawa"],
+  ["phayathai", "phaya thai"],
+  ["thonburi", "thon buri"],
+  ["bangkokyai", "bangkok yai"],
+  ["huaikhwang", "huai khwang"],
+  ["huaykhwang", "huai khwang"],
+  ["huaykwang", "huai khwang"],
+  ["khlongsan", "khlong san"],
+  ["klongsan", "khlong san"],
+  ["talingchan", "taling chan"],
+  ["bangkoknoi", "bangkok noi"],
+  ["bangkhunthian", "bang khun thian"],
+  ["phasicharoen", "phasi charoen"],
+  ["nongkhaem", "nong khaem"],
+  ["ratburana", "rat burana"],
+  ["bangphlat", "bang phlat"],
+  ["dindaeng", "din daeng"],
+  ["buengkum", "bueng kum"],
+  ["bangsue", "bang sue"],
+  ["bangkholaem", "bang kho laem"],
+  ["khlongtoei", "khlong toei"],
+  ["klongtoei", "khlong toei"],
+  ["klongtoey", "khlong toei"],
+  ["khlongtoey", "khlong toei"],
+  ["suanluang", "suan luang"],
+  ["chomthong", "chom thong"],
+  ["donmueang", "don mueang"],
+  ["donmuang", "don mueang"],
+  ["latphrao", "lat phrao"],
+  ["ladprao", "lat phrao"],
+  ["lardprao", "lat phrao"],
+  ["lat prao", "lat phrao"],
+  ["bangkhae", "bang khae"],
+  ["laksi", "lak si"],
+  ["saimai", "sai mai"],
+  ["khannayao", "khan na yao"],
+  ["saphansung", "saphan sung"],
+  ["wangthonglang", "wang thonglang"],
+  ["khlongsamwa", "khlong sam wa"],
+  ["klongsamwa", "khlong sam wa"],
+  ["bangna", "bang na"],
+  ["thawiwatthana", "thawi watthana"],
+  ["thungkhru", "thung khru"],
+  ["bangbon", "bang bon"],
+  // --- Bangkok area / street nicknames with a common misspelling ----------
+  ["sathorn", "sathon"],
+  ["wattana", "watthana"],
+  ["silom", "si lom"],
+  // --- Provinces and other high-traffic areas ------------------------------
+  ["krungthep", "bangkok"],
+  ["korat", "nakhon ratchasima"],
+  ["nakornratchasima", "nakhon ratchasima"],
+  ["chiangmai", "chiang mai"],
+  ["chiangrai", "chiang rai"],
+  ["pathumthani", "pathum thani"],
+  ["patumthani", "pathum thani"],
+  ["samutprakan", "samut prakan"],
+  ["samutsakhon", "samut sakhon"],
+  ["samutsongkhram", "samut songkhram"],
+  ["nakhonpathom", "nakhon pathom"],
+  ["nakhonsawan", "nakhon sawan"],
+  ["nakhonsithammarat", "nakhon si thammarat"],
+  ["prachuapkhirikhan", "prachuap khiri khan"],
+  ["huahin", "hua hin"],
+  ["hatyai", "hat yai"],
+  ["hadyai", "hat yai"],
+  ["had yai", "hat yai"],
+  ["lopburi", "loburi"],
+  ["lop buri", "loburi"],
+  ["buengkan", "buogkan"],
+  ["bungkan", "buogkan"],
+  ["bung kan", "buogkan"],
+  ["udonthani", "udon thani"],
+  ["khonkaen", "khon kaen"],
+  ["suphanburi", "suphan buri"],
+  ["nongkhai", "nong khai"],
+  ["buriram", "buri ram"]
+]);
+var NOISE_WORDS_RE = /\b(?:sub[- ]?district|district|province|changwat|amphoe|amphur)\b/g;
+var WHITESPACE_RE = /\s+/g;
+function cleanup(text) {
+  const stripped = text.replace(NOISE_WORDS_RE, " ").replace(WHITESPACE_RE, " ").trim();
+  return stripped.length > 0 ? stripped : text;
 }
-function clearDefaultIndex() {
+function applyRomanizationAliases(normalized) {
+  if (!normalized) return normalized;
+  const direct = ALIASES.get(normalized);
+  if (direct !== void 0) return direct;
+  const cleaned = cleanup(normalized);
+  if (cleaned === normalized) return normalized;
+  const aliasedCleaned = ALIASES.get(cleaned);
+  return aliasedCleaned !== void 0 ? aliasedCleaned : cleaned;
 }
 
 // src/core/search.ts
 var ZIP_CODE_RE = /^\d+$/;
+var HAS_LATIN_RE = /[a-z]/i;
+var TH_COLLATOR = new Intl.Collator("th");
+function compareZip(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function sortZipMatches(matches, exactZip) {
+  matches.sort((a, b) => {
+    if (a.zipCode === exactZip && b.zipCode !== exactZip) return -1;
+    if (b.zipCode === exactZip && a.zipCode !== exactZip) return 1;
+    return compareZip(a.zipCode, b.zipCode);
+  });
+  return matches;
+}
+function lookupByZipCode(index, zip, options) {
+  if (!index || !zip) return [];
+  const normalized = zip.trim();
+  if (!ZIP_CODE_RE.test(normalized) || normalized.length < 2) return [];
+  const zipLimit = options?.zipLimit ?? Infinity;
+  const matches = [];
+  for (const [z, indices] of index.zipIndex) {
+    if (z.startsWith(normalized)) {
+      for (const idx of indices) matches.push(index.records[idx]);
+    }
+  }
+  sortZipMatches(matches, normalized);
+  return matches.slice(0, zipLimit);
+}
+function rankAgainstName(name, query) {
+  if (name === void 0 || name.length === 0) return 0;
+  if (name === query) return 3;
+  if (name.startsWith(query)) return 2;
+  if (name.includes(query)) return 1;
+  return 0;
+}
+function computeMatchRank(index, idx, query) {
+  const th = rankAgainstName(index.normTambon?.[idx], query);
+  if (th === 3) return 3;
+  const en = rankAgainstName(index.normTambonEn?.[idx], query);
+  return en > th ? en : th;
+}
 function searchThaiAddress(index, query, options) {
   const limit = options?.limit ?? 10;
   const threshold = options?.threshold ?? 0.4;
   if (!index || !query) return [];
+  if (query.length > 1e3) return [];
   const normalized = normalizeThaiAddressText(query);
   if (normalized.length === 0) return [];
   if (normalized.length > 300) return [];
   if (ZIP_CODE_RE.test(normalized)) {
     if (normalized.length < 2) return [];
-    const matches = [];
-    for (const [zip, indices] of index.zipIndex) {
-      if (zip.startsWith(normalized)) {
-        for (const idx of indices) matches.push(index.records[idx]);
-      }
-    }
-    matches.sort((a, b) => {
-      if (a.zipCode === normalized && b.zipCode !== normalized) return -1;
-      if (b.zipCode === normalized && a.zipCode !== normalized) return 1;
-      return a.zipCode.localeCompare(b.zipCode);
+    return lookupByZipCode(index, normalized, {
+      zipLimit: options?.zipLimit ?? Infinity
     });
-    return matches.slice(0, limit);
   }
-  const queryTrigrams = extractTrigramsNormalized(normalized);
+  if (normalized.length < 3) return [];
+  const searchText = options?.romanizationAliases !== false && HAS_LATIN_RE.test(normalized) ? applyRomanizationAliases(normalized) : normalized;
+  const queryTrigrams = extractTrigramsNormalized(searchText);
   const hits = /* @__PURE__ */ new Map();
   for (const trigram of queryTrigrams) {
     const candidates = index.map.get(trigram);
@@ -131,23 +330,98 @@ function searchThaiAddress(index, query, options) {
   for (const [idx, count] of hits) {
     const score = count / queryTrigrams.size;
     if (score >= threshold) {
-      scored.push({ idx, score });
+      scored.push({ idx, score, matchRank: computeMatchRank(index, idx, searchText) });
     }
   }
   scored.sort((a, b) => {
     if (b.score !== a.score) return b.score - a.score;
+    return b.matchRank - a.matchRank;
+  });
+  const windowSize = Math.max(limit * 4, 50);
+  const window = scored.slice(0, windowSize);
+  window.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (b.matchRank !== a.matchRank) return b.matchRank - a.matchRank;
     const ra = index.records[a.idx];
     const rb = index.records[b.idx];
-    return ra.provinceNameTh.localeCompare(rb.provinceNameTh) || ra.amphureNameTh.localeCompare(rb.amphureNameTh) || ra.tambonNameTh.localeCompare(rb.tambonNameTh);
+    return TH_COLLATOR.compare(ra.provinceNameTh, rb.provinceNameTh) || TH_COLLATOR.compare(ra.amphureNameTh, rb.amphureNameTh) || TH_COLLATOR.compare(ra.tambonNameTh, rb.tambonNameTh);
+  });
+  return window.slice(0, limit).map(({ idx }) => index.records[idx]);
+}
+
+// src/core/enumerate.ts
+var thCollator = new Intl.Collator("th");
+function byNameTh(a, b) {
+  return thCollator.compare(a.nameTh, b.nameTh);
+}
+function listProvinces(index) {
+  const seen = /* @__PURE__ */ new Map();
+  if (index.byProvince) {
+    for (const [provinceId, recordIndices] of index.byProvince) {
+      if (seen.has(provinceId) || recordIndices.length === 0) continue;
+      const r = index.records[recordIndices[0]];
+      seen.set(provinceId, { id: provinceId, nameTh: r.provinceNameTh, nameEn: r.provinceNameEn });
+    }
+  } else {
+    for (const r of index.records) {
+      if (!seen.has(r.provinceId)) {
+        seen.set(r.provinceId, { id: r.provinceId, nameTh: r.provinceNameTh, nameEn: r.provinceNameEn });
+      }
+    }
+  }
+  return Array.from(seen.values()).sort(byNameTh);
+}
+function listAmphures(index, provinceId) {
+  const seen = /* @__PURE__ */ new Map();
+  const addFrom = (r) => {
+    if (!seen.has(r.amphureId)) {
+      seen.set(r.amphureId, {
+        id: r.amphureId,
+        nameTh: r.amphureNameTh,
+        nameEn: r.amphureNameEn,
+        provinceId: r.provinceId
+      });
+    }
+  };
+  if (index.byProvince) {
+    const recordIndices = index.byProvince.get(provinceId);
+    if (!recordIndices) return [];
+    for (const idx of recordIndices) addFrom(index.records[idx]);
+  } else {
+    for (const r of index.records) {
+      if (r.provinceId === provinceId) addFrom(r);
+    }
+  }
+  return Array.from(seen.values()).sort(byNameTh);
+}
+function listTambons(index, amphureId) {
+  const toSummary = (r) => ({
+    id: r.tambonId,
+    nameTh: r.tambonNameTh,
+    nameEn: r.tambonNameEn,
+    amphureId: r.amphureId,
+    zipCode: r.zipCode
   });
-  return scored.slice(0, limit).map(({ idx }) => index.records[idx]);
+  let result;
+  if (index.byAmphure) {
+    const recordIndices = index.byAmphure.get(amphureId);
+    if (!recordIndices) return [];
+    result = recordIndices.map((idx) => toSummary(index.records[idx]));
+  } else {
+    result = index.records.filter((r) => r.amphureId === amphureId).map(toSummary);
+  }
+  return result.sort(byNameTh);
 }
 
 // src/core/formatter.ts
-function formatThaiAddressSuggestion(record) {
+function formatThaiAddressSuggestion(record, options) {
+  const labelTh = `${record.tambonNameTh} > ${record.amphureNameTh} > ${record.provinceNameTh} ${record.zipCode}`;
+  const labelEn = `${record.tambonNameEn} > ${record.amphureNameEn} > ${record.provinceNameEn} ${record.zipCode}`;
   return {
     id: String(record.tambonId),
-    label: `${record.tambonNameTh} > ${record.amphureNameTh} > ${record.provinceNameTh} ${record.zipCode}`,
+    label: options?.locale === "en" ? labelEn : labelTh,
+    labelTh,
+    labelEn,
     tambon: record.tambonNameTh,
     tambonEn: record.tambonNameEn,
     amphure: record.amphureNameTh,
@@ -175,63 +449,7 @@ function resolveThaiAddress(record) {
     postalCode: record.zipCode
   };
 }
-function useThaiAddressAutocomplete(options) {
-  const { index, limit = 10, debounce: debounceMs = 200, threshold = 0.4 } = options;
-  const [query, setQueryState] = useState("");
-  const [suggestions, setSuggestions] = useState([]);
-  const timerRef = useRef(null);
-  const matchedRecordsMapRef = useRef(/* @__PURE__ */ new Map());
-  const setQuery = useCallback((value) => {
-    setQueryState(value);
-  }, []);
-  useEffect(() => {
-    if (timerRef.current) clearTimeout(timerRef.current);
-    if (query.length === 0) {
-      setSuggestions([]);
-      matchedRecordsMapRef.current = /* @__PURE__ */ new Map();
-      return;
-    }
-    timerRef.current = setTimeout(() => {
-      const records = searchThaiAddress(index, query, { limit, threshold });
-      const formatted = records.map(formatThaiAddressSuggestion);
-      const recordMap = /* @__PURE__ */ new Map();
-      for (let i = 0; i < records.length; i++) {
-        recordMap.set(formatted[i].id, records[i]);
-      }
-      matchedRecordsMapRef.current = recordMap;
-      setSuggestions(formatted);
-    }, debounceMs);
-    return () => {
-      if (timerRef.current) clearTimeout(timerRef.current);
-    };
-  }, [query, index, limit, threshold, debounceMs]);
-  const selectSuggestion = useCallback(
-    (item) => {
-      const record = matchedRecordsMapRef.current.get(item.id);
-      if (!record) {
-        throw new Error(`[thaizip] No record found for suggestion id "${item.id}". Make sure to use suggestions returned by this hook.`);
-      }
-      setSuggestions([]);
-      matchedRecordsMapRef.current = /* @__PURE__ */ new Map();
-      return resolveThaiAddress(record);
-    },
-    []
-  );
-  const clear = useCallback(() => {
-    setQueryState("");
-    setSuggestions([]);
-    matchedRecordsMapRef.current = /* @__PURE__ */ new Map();
-  }, []);
-  return {
-    query,
-    setQuery,
-    suggestions,
-    isOpen: query.length > 0 && suggestions.length > 0,
-    selectSuggestion,
-    clear
-  };
-}
 
-export { buildThaiAddressIndex, clearDefaultIndex, formatThaiAddressSuggestion, normalizeThaiAddressText, resolveThaiAddress, searchThaiAddress, useThaiAddressAutocomplete };
+export { applyRomanizationAliases, buildThaiAddressIndex, formatThaiAddressSuggestion, listAmphures, listProvinces, listTambons, lookupByZipCode, normalizeThaiAddressText, resolveThaiAddress, searchThaiAddress, validateRawData };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map