thaizip 0.5.1 → 0.7.2

package/dist/react.d.cts

@@ -0,0 +1,111 @@
+import * as react from 'react';
+
+type ThaiAddressRecord = {
+    provinceId: number;
+    provinceNameTh: string;
+    provinceNameEn: string;
+    amphureId: number;
+    amphureNameTh: string;
+    amphureNameEn: string;
+    tambonId: number;
+    tambonNameTh: string;
+    tambonNameEn: string;
+    zipCode: string;
+};
+type TrigramIndex = {
+    map: Map<string, Set<number>>;
+    records: ThaiAddressRecord[];
+    zipIndex: Map<string, number[]>;
+    /**
+     * Normalized Thai tambon names, parallel to `records` (same index).
+     * Used by the search ranker for exact/prefix match detection without
+     * re-normalizing on every query.
+     */
+    normTambon: string[];
+    /**
+     * Normalized English (RTGS) tambon names, parallel to `records`. Needed so
+     * romanized queries get the same own-name-beats-parent-name ranking that
+     * Thai queries get.
+     */
+    normTambonEn: string[];
+    /** Record indices grouped by `provinceId`, in insertion order. */
+    byProvince: Map<number, number[]>;
+    /** Record indices grouped by `amphureId`, in insertion order. */
+    byAmphure: Map<number, number[]>;
+};
+/** Which language a formatted label should be rendered in. */
+type AddressLocale = 'th' | 'en';
+type ThaiAddressSuggestion = {
+    id: string;
+    /** Human-readable label in the requested locale (Thai by default). */
+    label: string;
+    /** Human-readable label in Thai, regardless of the requested locale. */
+    labelTh: string;
+    /** Human-readable label in English, regardless of the requested locale. */
+    labelEn: string;
+    tambon: string;
+    tambonEn: string;
+    amphure: string;
+    amphureEn: string;
+    province: string;
+    provinceEn: string;
+    zipCode: string;
+};
+type ResolvedThaiAddress = {
+    tambon: string;
+    tambonEn: string;
+    amphure: string;
+    amphureEn: string;
+    province: string;
+    provinceEn: string;
+    zipCode: string;
+    subdistrict: string;
+    subdistrictEn: string;
+    district: string;
+    districtEn: string;
+    postalCode: string;
+};
+type UseThaiAddressAutocompleteOptions = {
+    index: TrigramIndex;
+    limit?: number;
+    debounce?: number;
+    threshold?: number;
+    zipLimit?: number;
+    /** Seed value for `query` on first render. Defaults to `''`. */
+    initialQuery?: string;
+    /** Locale for the `label` field of returned suggestions. Defaults to `'th'`. */
+    locale?: AddressLocale;
+    /** Called after a suggestion is successfully resolved via `selectSuggestion`. */
+    onSelect?: (address: ResolvedThaiAddress) => void;
+};
+
+/**
+ * Headless Thai address autocomplete hook.
+ *
+ * @param options.index - The TrigramIndex to search against. The hook reads `index`
+ *   via an internal ref, so a new object reference does NOT restart the debounce
+ *   timer. When `index` itself changes (e.g. swapped for a custom dataset), any
+ *   pending query is re-searched immediately with the new index.
+ * @param options.limit - Maximum number of suggestions (default 10).
+ * @param options.debounce - Debounce delay in ms (default 200).
+ * @param options.threshold - Minimum trigram score 0–1 (default 0.4).
+ * @param options.zipLimit - Maximum results for all-digit (zip code) queries, passed
+ *   through to `searchThaiAddress`.
+ * @param options.initialQuery - Seed value for `query` on first render. Does NOT
+ *   trigger a search — useful for pre-filling the input with an already-chosen
+ *   address (e.g. react-hook-form `defaultValues`) without popping the dropdown open.
+ * @param options.locale - Locale for the `label` field of returned suggestions.
+ * @param options.onSelect - Called with the resolved address after a successful
+ *   `selectSuggestion`.
+ */
+declare function useThaiAddressAutocomplete(options: UseThaiAddressAutocompleteOptions): {
+    query: string;
+    setQuery: react.Dispatch<react.SetStateAction<string>>;
+    setQuerySilent: (value: string) => void;
+    suggestions: ThaiAddressSuggestion[];
+    isOpen: boolean;
+    selectSuggestion: (item: ThaiAddressSuggestion) => ResolvedThaiAddress | null;
+    clear: () => void;
+};
+
+export { type ResolvedThaiAddress, type ThaiAddressSuggestion, type TrigramIndex, type UseThaiAddressAutocompleteOptions, useThaiAddressAutocomplete };

package/dist/react.d.ts

@@ -0,0 +1,111 @@
+import * as react from 'react';
+
+type ThaiAddressRecord = {
+    provinceId: number;
+    provinceNameTh: string;
+    provinceNameEn: string;
+    amphureId: number;
+    amphureNameTh: string;
+    amphureNameEn: string;
+    tambonId: number;
+    tambonNameTh: string;
+    tambonNameEn: string;
+    zipCode: string;
+};
+type TrigramIndex = {
+    map: Map<string, Set<number>>;
+    records: ThaiAddressRecord[];
+    zipIndex: Map<string, number[]>;
+    /**
+     * Normalized Thai tambon names, parallel to `records` (same index).
+     * Used by the search ranker for exact/prefix match detection without
+     * re-normalizing on every query.
+     */
+    normTambon: string[];
+    /**
+     * Normalized English (RTGS) tambon names, parallel to `records`. Needed so
+     * romanized queries get the same own-name-beats-parent-name ranking that
+     * Thai queries get.
+     */
+    normTambonEn: string[];
+    /** Record indices grouped by `provinceId`, in insertion order. */
+    byProvince: Map<number, number[]>;
+    /** Record indices grouped by `amphureId`, in insertion order. */
+    byAmphure: Map<number, number[]>;
+};
+/** Which language a formatted label should be rendered in. */
+type AddressLocale = 'th' | 'en';
+type ThaiAddressSuggestion = {
+    id: string;
+    /** Human-readable label in the requested locale (Thai by default). */
+    label: string;
+    /** Human-readable label in Thai, regardless of the requested locale. */
+    labelTh: string;
+    /** Human-readable label in English, regardless of the requested locale. */
+    labelEn: string;
+    tambon: string;
+    tambonEn: string;
+    amphure: string;
+    amphureEn: string;
+    province: string;
+    provinceEn: string;
+    zipCode: string;
+};
+type ResolvedThaiAddress = {
+    tambon: string;
+    tambonEn: string;
+    amphure: string;
+    amphureEn: string;
+    province: string;
+    provinceEn: string;
+    zipCode: string;
+    subdistrict: string;
+    subdistrictEn: string;
+    district: string;
+    districtEn: string;
+    postalCode: string;
+};
+type UseThaiAddressAutocompleteOptions = {
+    index: TrigramIndex;
+    limit?: number;
+    debounce?: number;
+    threshold?: number;
+    zipLimit?: number;
+    /** Seed value for `query` on first render. Defaults to `''`. */
+    initialQuery?: string;
+    /** Locale for the `label` field of returned suggestions. Defaults to `'th'`. */
+    locale?: AddressLocale;
+    /** Called after a suggestion is successfully resolved via `selectSuggestion`. */
+    onSelect?: (address: ResolvedThaiAddress) => void;
+};
+
+/**
+ * Headless Thai address autocomplete hook.
+ *
+ * @param options.index - The TrigramIndex to search against. The hook reads `index`
+ *   via an internal ref, so a new object reference does NOT restart the debounce
+ *   timer. When `index` itself changes (e.g. swapped for a custom dataset), any
+ *   pending query is re-searched immediately with the new index.
+ * @param options.limit - Maximum number of suggestions (default 10).
+ * @param options.debounce - Debounce delay in ms (default 200).
+ * @param options.threshold - Minimum trigram score 0–1 (default 0.4).
+ * @param options.zipLimit - Maximum results for all-digit (zip code) queries, passed
+ *   through to `searchThaiAddress`.
+ * @param options.initialQuery - Seed value for `query` on first render. Does NOT
+ *   trigger a search — useful for pre-filling the input with an already-chosen
+ *   address (e.g. react-hook-form `defaultValues`) without popping the dropdown open.
+ * @param options.locale - Locale for the `label` field of returned suggestions.
+ * @param options.onSelect - Called with the resolved address after a successful
+ *   `selectSuggestion`.
+ */
+declare function useThaiAddressAutocomplete(options: UseThaiAddressAutocompleteOptions): {
+    query: string;
+    setQuery: react.Dispatch<react.SetStateAction<string>>;
+    setQuerySilent: (value: string) => void;
+    suggestions: ThaiAddressSuggestion[];
+    isOpen: boolean;
+    selectSuggestion: (item: ThaiAddressSuggestion) => ResolvedThaiAddress | null;
+    clear: () => void;
+};
+
+export { type ResolvedThaiAddress, type ThaiAddressSuggestion, type TrigramIndex, type UseThaiAddressAutocompleteOptions, useThaiAddressAutocomplete };

package/dist/react.js

@@ -0,0 +1,372 @@
+"use client";
+import { useRef, useState, useCallback, useEffect } from 'react';
+
+// src/core/normalizer.ts
+var TONE_MARKS = /[่-๋็์]/g;
+var ADDRESS_PREFIXES = /^(จังหวัด|อำเภอ|ตำบล|แขวง|เขต|จ\.|อ\.|ต\.|ข\.)/;
+function normalizeThaiAddressText(input) {
+  if (!input) return "";
+  let text = input.trim();
+  text = text.replace(ADDRESS_PREFIXES, "").trim();
+  text = text.replace(TONE_MARKS, "");
+  text = text.toLowerCase();
+  return text;
+}
+
+// src/core/trigrams.ts
+function extractTrigramsNormalized(text) {
+  const result = /* @__PURE__ */ new Set();
+  if (text.length === 0) return result;
+  if (text.length < 3) {
+    result.add(text);
+    return result;
+  }
+  for (let i = 0; i <= text.length - 3; i++) {
+    result.add(text.slice(i, i + 3));
+  }
+  return result;
+}
+
+// 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 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 [];
+    return lookupByZipCode(index, normalized, {
+      zipLimit: options?.zipLimit ?? Infinity
+    });
+  }
+  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);
+    if (!candidates) continue;
+    for (const idx of candidates) {
+      hits.set(idx, (hits.get(idx) ?? 0) + 1);
+    }
+  }
+  const scored = [];
+  for (const [idx, count] of hits) {
+    const score = count / queryTrigrams.size;
+    if (score >= threshold) {
+      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 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/formatter.ts
+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: options?.locale === "en" ? labelEn : labelTh,
+    labelTh,
+    labelEn,
+    tambon: record.tambonNameTh,
+    tambonEn: record.tambonNameEn,
+    amphure: record.amphureNameTh,
+    amphureEn: record.amphureNameEn,
+    province: record.provinceNameTh,
+    provinceEn: record.provinceNameEn,
+    zipCode: record.zipCode
+  };
+}
+
+// src/core/resolver.ts
+function resolveThaiAddress(record) {
+  return {
+    tambon: record.tambonNameTh,
+    tambonEn: record.tambonNameEn,
+    amphure: record.amphureNameTh,
+    amphureEn: record.amphureNameEn,
+    province: record.provinceNameTh,
+    provinceEn: record.provinceNameEn,
+    zipCode: record.zipCode,
+    subdistrict: record.tambonNameTh,
+    subdistrictEn: record.tambonNameEn,
+    district: record.amphureNameTh,
+    districtEn: record.amphureNameEn,
+    postalCode: record.zipCode
+  };
+}
+
+// src/react/useThaiAddressAutocomplete.ts
+function useThaiAddressAutocomplete(options) {
+  const {
+    index,
+    limit = 10,
+    debounce: debounceMs = 200,
+    threshold = 0.4,
+    zipLimit,
+    initialQuery = "",
+    locale,
+    onSelect
+  } = options;
+  const indexRef = useRef(index);
+  indexRef.current = index;
+  const [query, setQuery] = useState(initialQuery);
+  const [suggestions, setSuggestions] = useState([]);
+  const timerRef = useRef(null);
+  const matchedRecordsMapRef = useRef(/* @__PURE__ */ new Map());
+  const suppressNextSearchRef = useRef(initialQuery.length > 0);
+  const isFirstIndexEffectRunRef = useRef(true);
+  const runSearch = useCallback(
+    (q, idx) => {
+      const records = searchThaiAddress(idx, q, { limit, threshold, zipLimit });
+      const formatted = records.map((record) => formatThaiAddressSuggestion(record, { locale }));
+      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);
+    },
+    [limit, threshold, zipLimit, locale]
+  );
+  useEffect(() => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    if (query.length === 0) {
+      setSuggestions([]);
+      matchedRecordsMapRef.current = /* @__PURE__ */ new Map();
+      return;
+    }
+    if (suppressNextSearchRef.current) {
+      suppressNextSearchRef.current = false;
+      return;
+    }
+    timerRef.current = setTimeout(() => {
+      runSearch(query, indexRef.current);
+    }, debounceMs);
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, [query, limit, threshold, debounceMs, zipLimit, locale, runSearch]);
+  useEffect(() => {
+    if (isFirstIndexEffectRunRef.current) {
+      isFirstIndexEffectRunRef.current = false;
+      return;
+    }
+    if (query.length === 0) return;
+    if (suppressNextSearchRef.current) {
+      suppressNextSearchRef.current = false;
+      return;
+    }
+    if (timerRef.current) clearTimeout(timerRef.current);
+    runSearch(query, index);
+  }, [index]);
+  const selectSuggestion = useCallback(
+    (item) => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      const record = matchedRecordsMapRef.current.get(item.id);
+      if (!record) {
+        return null;
+      }
+      setSuggestions([]);
+      matchedRecordsMapRef.current = /* @__PURE__ */ new Map();
+      const resolved = resolveThaiAddress(record);
+      onSelect?.(resolved);
+      return resolved;
+    },
+    [onSelect]
+  );
+  const clear = useCallback(() => {
+    setQuery("");
+    setSuggestions([]);
+    matchedRecordsMapRef.current = /* @__PURE__ */ new Map();
+  }, []);
+  const setQuerySilent = useCallback((value) => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    if (value.length > 0) suppressNextSearchRef.current = true;
+    setSuggestions([]);
+    matchedRecordsMapRef.current = /* @__PURE__ */ new Map();
+    setQuery(value);
+  }, []);
+  return {
+    query,
+    setQuery,
+    setQuerySilent,
+    suggestions,
+    isOpen: query.length > 0 && suggestions.length > 0,
+    selectSuggestion,
+    clear
+  };
+}
+
+export { useThaiAddressAutocomplete };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map