@whiteslove/parsing-lexicon 0.2.0

package/src/housing-money.js

@@ -0,0 +1,102 @@
+import { aliasesOf, findCanonical } from './normalization.js';
+import { CURRENCY_TERMS, NUMBER_MULTIPLIERS } from './money-lexicon.js';
+import {
+  MONEY_NUMBER_PATTERN,
+  moneyCurrencyFromText,
+  moneyCurrencyPattern,
+  parseNumericAmount,
+  parseScaledAmount,
+} from './money-core.js';
+import { maskPhoneLikeSpans } from './contact.js';
+
+const PRICE_KEYWORD = '(?:цена|ціна|нарх(?:и)?|narx|price|стоимост[ьи]|аренд(?:а|ная\\s+плата)?|rent)';
+const PRICE_CURRENCY = `(?:${moneyCurrencyPattern()})`;
+
+function escapeRegex(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function parseHousingPrice(value, fallbackCurrency = '') {
+  const original = String(value || '');
+  if (!original) return Object.freeze({ price: null, currency: fallbackCurrency || '' });
+
+  // Contact spans are removed once, before every money branch. A phone can
+  // therefore never win as a labelled, currency-tagged or fallback amount.
+  const text = maskPhoneLikeSpans(original);
+  let currency = moneyCurrencyFromText(text, fallbackCurrency || '') || '';
+  const explicit = Boolean(findCanonical(text, CURRENCY_TERMS, { partial: true }));
+  let price = null;
+
+  // Common Ukrainian/Russian classifieds shorthand: "10 т грн" / "10 т гр".
+  // Keep this housing-specific instead of adding globally ambiguous aliases
+  // `т` (tonne) and `гр` (gram) to the shared money lexicon. A nearby price
+  // keyword plus an explicit hryvnia shorthand makes the intent unambiguous.
+  const compactThousandUah = text.match(new RegExp(
+    `${PRICE_KEYWORD}[^\\r\\n]{0,48}?(\\d{1,6}(?:[.,]\\d{1,2})?)\\s*т(?:ыс\\.?)?\\s*(?:гр(?:н)?|₴|uah)(?=$|[^\\p{L}\\p{N}_])`,
+    'iu',
+  ));
+  if (compactThousandUah) {
+    const amount = parseNumericAmount(compactThousandUah[1]);
+    if (amount != null && amount >= 1 && amount <= 5_000_000) {
+      price = Math.round(amount * 1000);
+      currency = 'UAH';
+    }
+  }
+
+  const labelled = text.match(new RegExp(`${PRICE_KEYWORD}\\s*[:\\-–—]?\\s*(${MONEY_NUMBER_PATTERN})`, 'i'));
+  if (price == null && labelled) {
+    const amount = parseNumericAmount(labelled[1]);
+    if (amount != null && amount >= 50 && amount <= 5_000_000_000) price = amount;
+  }
+
+  if (price == null) {
+    let tagged = null;
+    const reNumSym = new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*${PRICE_CURRENCY}`, 'ig');
+    const reSymNum = new RegExp(`${PRICE_CURRENCY}\\s*(${MONEY_NUMBER_PATTERN})`, 'ig');
+    for (const regex of [reNumSym, reSymNum]) {
+      let match;
+      while ((match = regex.exec(text)) !== null) {
+        const amount = parseNumericAmount(match[1]);
+        if (amount != null && amount >= 50 && amount <= 5_000_000_000 && (tagged == null || amount > tagged)) tagged = amount;
+      }
+    }
+    price = tagged;
+  }
+
+  if (price == null) {
+    const scalePattern = [...new Set(NUMBER_MULTIPLIERS.flatMap((entry) => aliasesOf(entry)).filter(Boolean))]
+      .sort((a, b) => String(b).length - String(a).length)
+      .map(escapeRegex)
+      .join('|');
+    // Multiplier aliases include useful one-letter forms such as `m` and `k`.
+    // Require the alias to end at a token boundary so measurements/words like
+    // `500 m2` and `5 minut` cannot be promoted to 500 million / 5 million.
+    const match = text.match(new RegExp(`(\\d+(?:[.,]\\d+)?)\\s*(${scalePattern})(?=$|[^\\p{L}\\p{N}_])`, 'iu'));
+    if (match) {
+      const amount = parseScaledAmount(match[1], match[2]);
+      if (amount != null && amount >= 1000 && amount <= 5_000_000_000) price = Math.round(amount);
+    }
+  }
+
+  if (price == null) {
+    const matches = text.match(/\d{1,3}(?:[ \u00A0.,]\d{3})+|\d{4,}/g) || [];
+    let best = null;
+    for (const raw of matches) {
+      const digits = raw.replace(/[\s.,]/g, '');
+      if (digits[0] === '0') continue;
+      const amount = parseNumericAmount(raw);
+      if (amount != null && amount >= 1000 && amount <= 5_000_000_000 && (best == null || amount > best)) best = amount;
+    }
+    price = best;
+  }
+
+  if (!explicit && fallbackCurrency === 'UZS' && price != null) {
+    const dailyUzbek = /(?:kunlik|sutkaga|kecha[- ]?kunduz|посуточн|суточн)/i.test(text);
+    currency = price >= 1_000_000 || (dailyUzbek && price >= 10_000) ? 'UZS' : 'USD';
+  }
+
+  return Object.freeze({ price, currency });
+}
+
+// Compatibility name for callers migrating from Flat Finder's local parser.
+export const parsePriceFromText = parseHousingPrice;

package/src/housing-source-aliases.d.ts

@@ -0,0 +1,8 @@
+export const HOUSING_DEAL_TYPE_EXTENSIONS: readonly unknown[];
+export const HOUSING_ROOM_ONLY_EXTENSIONS: readonly unknown[];
+export function resolveExtendedHousingIntent(value: unknown): Readonly<{
+  action: string | null;
+  listingKind: string | null;
+  dealType: 'sale' | 'longRent' | 'shortRent';
+}> | null;
+export function isRoomOnlyHousing(value: unknown): boolean;

package/src/housing-source-aliases.js

@@ -0,0 +1,51 @@
+import { lexiconEntity } from './lexicon-core.js';
+import { findCanonical } from './normalization.js';
+import { resolveHousingIntent } from './housing-intent.js';
+import { HOUSING_OCCUPANCY_TYPES, PROPERTY_TYPES } from './housing.js';
+
+const group = (canonical, aliases, extra = {}) => lexiconEntity(canonical, aliases, extra);
+
+/** Source/feed wording that is useful for normalization but too noisy for the generic core. */
+export const HOUSING_DEAL_TYPE_EXTENSIONS = Object.freeze([
+  group('longRent', {
+    ru: ['снять', 'в месяц', 'месяц'],
+    en: ['monthly'],
+    uzLatn: ['ijaraga', 'oyiga', 'beriladi'],
+    uzCyrl: ['ижарага', 'ойига', 'берилади'],
+    kk: ['айына'],
+  }),
+  group('shortRent', {
+    ru: ['сутки', 'суток', 'суточно'],
+    en: ['daily'],
+    uzLatn: ['kunlik', 'sutkalik'],
+    uzCyrl: ['кунлик', 'суткалик'],
+    kk: ['тәуліктік'],
+  }),
+]);
+
+export const HOUSING_ROOM_ONLY_EXTENSIONS = Object.freeze([
+  group('roomOnly', {
+    ru: ['шеринг'],
+    en: ['room only'],
+    uzLatn: ['student qizlarga', 'talaba qizlarga', 'opshijit dom', 'obshijit dom'],
+    uzCyrl: ['студент қизларга', 'талаба қизларга'],
+  }),
+]);
+
+export function resolveExtendedHousingIntent(value) {
+  const text = String(value || '');
+  const base = resolveHousingIntent(text);
+  if (base) return base;
+  const deal = findCanonical(text, HOUSING_DEAL_TYPE_EXTENSIONS, { partial: true });
+  if (!deal?.canonical) return null;
+  return Object.freeze({ action: null, listingKind: null, dealType: deal.canonical });
+}
+
+export function isRoomOnlyHousing(value) {
+  const text = String(value || '');
+  if (!text.trim()) return false;
+  const occupancy = findCanonical(text, HOUSING_OCCUPANCY_TYPES, { partial: true })?.canonical;
+  if (occupancy && ['room', 'sharedRoom', 'bedSpace'].includes(occupancy)) return true;
+  if (findCanonical(text, PROPERTY_TYPES, { partial: true })?.canonical === 'dormitory') return true;
+  return Boolean(findCanonical(text, HOUSING_ROOM_ONLY_EXTENSIONS, { partial: true }));
+}

package/src/housing-structured.d.ts

@@ -0,0 +1,55 @@
+export type HousingAreaDetails = Readonly<{
+  total: number | null;
+  living: number | null;
+  kitchen: number | null;
+  balcony: number | null;
+  terrace: number | null;
+}>;
+
+export type HousingPaymentContext = Readonly<{
+  deposit: Readonly<{
+    required: boolean | null;
+    kind: string | null;
+    amount: number | null;
+    currency: string | null;
+  }>;
+  prepaymentMonths: number | null;
+  utilities: string | null;
+  commission: Readonly<{
+    required: boolean | null;
+    percent: number | null;
+  }>;
+}>;
+
+export type HousingInfrastructureDistance = Readonly<{
+  value: number | null;
+  unit: 'minute' | 'meter' | 'kilometer';
+  mode: 'walk' | 'drive' | null;
+}>;
+
+export type HousingInfrastructureMatch = Readonly<{
+  poi: string;
+  relation: string | null;
+  distance: HousingInfrastructureDistance | null;
+  start: number;
+  end: number;
+}>;
+
+export type HousingStructuredResult = Readonly<{
+  intent: Readonly<{ action: string | null; listingKind: string | null; dealType: string }> | null;
+  context: Readonly<Record<string, unknown>>;
+  rooms: number | null;
+  floor: Readonly<{ floor: number | null; totalFloors: number | null }>;
+  area: HousingAreaDetails;
+  payments: HousingPaymentContext;
+  seller: Readonly<{ type: 'owner' | 'agency' | null; confidence: number }>;
+  infrastructure: readonly HousingInfrastructureMatch[];
+}>;
+
+export function parseHousingRoomCount(value: unknown): number | null;
+export function parseHousingFloor(value: unknown): Readonly<{ floor: number | null; totalFloors: number | null }>;
+export function parseHousingAreas(value: unknown): HousingAreaDetails;
+export function parseHousingPayments(value: unknown): HousingPaymentContext;
+export function parseHousingSeller(value: unknown): Readonly<{ type: 'owner' | 'agency' | null; confidence: number }>;
+export function parseHousingInfrastructure(value: unknown): readonly HousingInfrastructureMatch[];
+export function parseHousingStructured(value: unknown): HousingStructuredResult;

package/src/housing-structured.js

@@ -0,0 +1,219 @@
+import { deepFreeze } from './lexicon-core.js';
+import { findAllCanonical, findCanonical, normalizeUnicode } from './normalization.js';
+import { CURRENCY_TERMS } from './money.js';
+import { DEPOSIT_TERMS, SELLER_TERMS, UTILITY_TERMS } from './housing.js';
+import { GENERIC_LANDMARK_TERMS } from './landmarks.js';
+import { LOCATION_RELATIONS, parseHousingContext } from './housing-context.js';
+import { resolveHousingIntent } from './housing-intent.js';
+
+const NUMBER_WORDS = Object.freeze([
+  [/(?<![\p{L}\p{N}_])(?:однушк\p{L}*|однокомнатн\p{L}*|1\s*[- ]?к(?:омн\p{L}*)?|1\s*xona(?:li)?|1\s*бөлмелі|one[- ]bedroom|one[- ]room)(?![\p{L}\p{N}_])/iu, 1],
+  [/(?<![\p{L}\p{N}_])(?:двушк\p{L}*|двухкомнатн\p{L}*|2\s*[- ]?к(?:омн\p{L}*)?|2\s*xona(?:li)?|2\s*бөлмелі|two[- ]bedroom|two[- ]room)(?![\p{L}\p{N}_])/iu, 2],
+  [/(?<![\p{L}\p{N}_])(?:тр[её]шк\p{L}*|трехкомнатн\p{L}*|трёхкомнатн\p{L}*|3\s*[- ]?к(?:омн\p{L}*)?|3\s*xona(?:li)?|3\s*бөлмелі|three[- ]bedroom|three[- ]room)(?![\p{L}\p{N}_])/iu, 3],
+  [/(?<![\p{L}\p{N}_])(?:четыр[её]хкомнатн\p{L}*|четыр[её]шк\p{L}*|4\s*[- ]?к(?:омн\p{L}*)?|4\s*xona(?:li)?|4\s*бөлмелі|four[- ]bedroom|four[- ]room)(?![\p{L}\p{N}_])/iu, 4],
+]);
+
+function toNumber(value) {
+  if (value == null) return null;
+  const normalized = String(value).replace(/\s+/g, '').replace(',', '.');
+  const number = Number(normalized);
+  return Number.isFinite(number) ? number : null;
+}
+
+function currencyNear(text) {
+  return findCanonical(text, CURRENCY_TERMS, { partial: true })?.canonical || null;
+}
+
+export function parseHousingRoomCount(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text) return null;
+  for (const [re, rooms] of NUMBER_WORDS) if (re.test(text)) return rooms;
+  const numeric = text.match(/(?:^|[^\p{L}\p{N}])(\d{1,2})\s*(?:[- ]?комнат\p{L}*|[- ]?к(?:\.|\b)|xona(?:li)?|бөлмелі|rooms?)(?=$|[^\p{L}\p{N}])/iu);
+  const rooms = toNumber(numeric?.[1]);
+  return rooms != null && rooms >= 1 && rooms <= 20 ? rooms : null;
+}
+
+export function parseHousingFloor(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text) return deepFreeze({ floor: null, totalFloors: null });
+
+  const fraction = text.match(/(?:^|[^\d])(\d{1,3})\s*\/\s*(\d{1,3})(?=$|[^\d])/u);
+  if (fraction) {
+    const floor = toNumber(fraction[1]);
+    const totalFloors = toNumber(fraction[2]);
+    if (floor != null && totalFloors != null && floor <= totalFloors && totalFloors <= 200) {
+      return deepFreeze({ floor, totalFloors });
+    }
+  }
+
+  const explicit = text.match(/(?:этаж|поверх|floor|etaj|qavat|қабат)\s*[:№#-]?\s*(\d{1,3})\s*(?:[,;/]|из|of|din|dan)?\s*(?:дом\s*)?(?:из\s*)?(\d{1,3})?\s*(?:этаж\p{L}*|поверх\p{L}*|floors?|etaje|qavatli|қабатты)?/iu);
+  let floor = toNumber(explicit?.[1]);
+  let totalFloors = toNumber(explicit?.[2]);
+
+  if (totalFloors == null) {
+    const total = text.match(/(?:дом\s*)?(\d{1,3})\s*(?:[- ]?этажн\p{L}*|поверхов\p{L}*|storey|story|floors?\s+total|qavatli|қабатты)/iu);
+    totalFloors = toNumber(total?.[1]);
+  }
+
+  if (floor != null && (floor < -5 || floor > 200)) floor = null;
+  if (totalFloors != null && (totalFloors < 1 || totalFloors > 200)) totalFloors = null;
+  if (floor != null && totalFloors != null && floor > totalFloors) totalFloors = null;
+  return deepFreeze({ floor, totalFloors });
+}
+
+const AREA_LABELS = Object.freeze([
+  ['living', /(?:жилая\s+площадь|жилая|living\s+area|suprafa(?:ță|ta)\s+locuibil(?:ă|a)|yashash\s+maydoni|тұрғын\s+аудан)/iu],
+  ['kitchen', /(?:площадь\s+кухни|кухня|kitchen(?:\s+area)?|bucătărie|bucatarie|oshxona|асүй)/iu],
+  ['balcony', /(?:балкон|лоджия|balcony|loggia|balcon|balkon)/iu],
+  ['terrace', /(?:терраса|terrace|teras(?:ă|a)|terrasa)/iu],
+  ['total', /(?:общая\s+площадь|площадь|total\s+area|surface\s+area|suprafa(?:ță|ta)(?:\s+total(?:ă|a))?|umumiy\s+maydon|жалпы\s+аудан)/iu],
+]);
+
+function areaAfterLabel(text, labelRe) {
+  const re = new RegExp(`${labelRe.source}\\s*[:=-]?\\s*(\\d{1,4}(?:[.,]\\d{1,2})?)\\s*(?:м²|м2|m²|m2|sqm|sq\\.?\\s*m|mp|кв\\.?\\s*м)`, 'iu');
+  return toNumber(text.match(re)?.[1]);
+}
+
+export function parseHousingAreas(value) {
+  const text = normalizeUnicode(value ?? '');
+  const result = { total: null, living: null, kitchen: null, balcony: null, terrace: null };
+  if (!text) return deepFreeze(result);
+
+  for (const [key, re] of AREA_LABELS) result[key] = areaAfterLabel(text, re);
+  if (result.total == null) {
+    const generic = text.match(/(?:^|[^\d])(\d{1,4}(?:[.,]\d{1,2})?)\s*(?:м²|м2|m²|m2|sqm|sq\.?\s*m|mp)(?=$|[^\p{L}\p{N}])/iu);
+    result.total = toNumber(generic?.[1]);
+  }
+  for (const key of Object.keys(result)) {
+    const number = result[key];
+    if (number != null && (number <= 0 || number > 100000)) result[key] = null;
+  }
+  return deepFreeze(result);
+}
+
+function amountAroundKeyword(text, keywordRe) {
+  const after = text.match(new RegExp(`${keywordRe.source}[^\\d$€₴₸]{0,24}([$€₴₸])?\\s*(\\d{1,9}(?:[.,]\\d{1,2})?)\\s*([\\p{L}.']{0,12})`, 'iu'));
+  const before = text.match(new RegExp(`([$€₴₸])?\\s*(\\d{1,9}(?:[.,]\\d{1,2})?)\\s*([\\p{L}.']{0,12})[^\\d]{0,16}${keywordRe.source}`, 'iu'));
+  const match = after || before;
+  if (!match) return { amount: null, currency: null };
+  const amount = toNumber(match[2]);
+  const context = match[0];
+  return { amount, currency: currencyNear(context) };
+}
+
+export function parseHousingPayments(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text) return deepFreeze({
+    deposit: { required: null, kind: null, amount: null, currency: null },
+    prepaymentMonths: null,
+    utilities: null,
+    commission: { required: null, percent: null },
+  });
+
+  const depositMatches = Object.values(DEPOSIT_TERMS)
+    .map((entry) => findCanonical(text, [entry], { partial: true })?.canonical)
+    .filter(Boolean);
+  const depositPriority = ['noDeposit', 'firstAndLastMonth', 'advance', 'refundableDeposit', 'deposit'];
+  const depositKind = depositPriority.find((item) => depositMatches.includes(item)) || null;
+  const depositAmount = amountAroundKeyword(text, /(?:депозит|залог|deposit|depozit|garanție|garantie|кепіл)/iu);
+
+  let prepaymentMonths = toNumber(text.match(/(?:предоплат\p{L}*|оплат\p{L}*\s+впер[её]д|prepay(?:ment)?|advance\s+payment|oldindan\s+to['’]?lov|алдын\s+ала\s+төлем)\D{0,18}(\d{1,2})\s*(?:месяц\p{L}*|months?|oy|ай)/iu)?.[1]);
+  if (depositKind === 'firstAndLastMonth' && prepaymentMonths == null) prepaymentMonths = 2;
+
+  let utilities = null;
+  for (const entry of Object.values(UTILITY_TERMS)) {
+    const matched = findCanonical(text, [entry], { partial: true });
+    if (matched) { utilities = matched.canonical; break; }
+  }
+
+  const noCommission = SELLER_TERMS.noCommission && findCanonical(text, [SELLER_TERMS.noCommission], { partial: true });
+  const commissionPercent = toNumber(text.match(/(?:комисси\p{L}*|commission|comision|komissiya)[^\d%]{0,16}(\d{1,3}(?:[.,]\d+)?)\s*%/iu)?.[1]);
+  const commissionMentioned = SELLER_TERMS.commission && findCanonical(text, [SELLER_TERMS.commission], { partial: true });
+
+  return deepFreeze({
+    deposit: {
+      required: depositKind === 'noDeposit' ? false : depositKind ? true : null,
+      kind: depositKind,
+      amount: depositAmount.amount,
+      currency: depositAmount.currency,
+    },
+    prepaymentMonths,
+    utilities,
+    commission: {
+      required: noCommission ? false : (commissionMentioned || commissionPercent != null ? true : null),
+      percent: commissionPercent,
+    },
+  });
+}
+
+export function parseHousingSeller(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text) return deepFreeze({ type: null, confidence: 0 });
+  const owner = SELLER_TERMS.owner && findCanonical(text, [SELLER_TERMS.owner], { partial: true });
+  const agency = SELLER_TERMS.agency && findCanonical(text, [SELLER_TERMS.agency], { partial: true });
+  if (owner && !agency) return deepFreeze({ type: 'owner', confidence: 1 });
+  if (agency && !owner) return deepFreeze({ type: 'agency', confidence: 1 });
+  if (owner && agency) return deepFreeze({ type: null, confidence: 0.45 });
+  return deepFreeze({ type: null, confidence: 0 });
+}
+
+function distanceFromWindow(window, entityOffset = 0) {
+  const candidates = [];
+  const minuteRe = /(\d{1,3})\s*(?:мин(?:ут[аы]?)?|minutes?|min\.?|daqiqa|минут|мин|минөт)/giu;
+  for (const match of window.matchAll(minuteRe)) {
+    const index = match.index ?? 0;
+    const local = window.slice(Math.max(0, index - 18), Math.min(window.length, index + match[0].length + 28));
+    const mode = /(?:пешком|walk(?:ing)?|on\s+foot|piyoda|жаяу)/iu.test(local)
+      ? 'walk'
+      : /(?:на\s+машине|by\s+car|drive|mashinada|көлікпен)/iu.test(local) ? 'drive' : null;
+    candidates.push({ distance: Math.abs(index - entityOffset), value: Number(match[1]), unit: 'minute', mode });
+  }
+  const metricRe = /(\d{1,4}(?:[.,]\d+)?)\s*(км|km|километр\p{L}*|м|meter(?:s)?|метр\p{L}*)/giu;
+  for (const match of window.matchAll(metricRe)) {
+    const index = match.index ?? 0;
+    const rawUnit = match[2].toLocaleLowerCase();
+    candidates.push({ distance: Math.abs(index - entityOffset), value: toNumber(match[1]), unit: /км|km|километр/u.test(rawUnit) ? 'kilometer' : 'meter', mode: null });
+  }
+  candidates.sort((a, b) => a.distance - b.distance);
+  if (!candidates.length) return null;
+  const { value, unit, mode } = candidates[0];
+  return { value, unit, mode };
+}
+
+export function parseHousingInfrastructure(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text) return [];
+  const matches = findAllCanonical(text, GENERIC_LANDMARK_TERMS);
+  const out = [];
+  const seen = new Set();
+  for (const match of matches) {
+    const key = `${match.canonical}:${match.start}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const left = Math.max(0, match.start - 80);
+    const right = Math.min(text.length, match.end + 80);
+    const window = text.slice(left, right);
+    out.push(deepFreeze({
+      poi: match.canonical,
+      relation: findCanonical(window, LOCATION_RELATIONS, { partial: true })?.canonical || null,
+      distance: distanceFromWindow(window, match.start - left),
+      start: match.start,
+      end: match.end,
+    }));
+  }
+  return Object.freeze(out);
+}
+
+export function parseHousingStructured(value) {
+  const text = String(value ?? '');
+  return deepFreeze({
+    intent: resolveHousingIntent(text),
+    context: parseHousingContext(text),
+    rooms: parseHousingRoomCount(text),
+    floor: parseHousingFloor(text),
+    area: parseHousingAreas(text),
+    payments: parseHousingPayments(text),
+    seller: parseHousingSeller(text),
+    infrastructure: parseHousingInfrastructure(text),
+  });
+}