@whiteslove/parsing-lexicon 0.2.6 → 0.2.7

package/index.d.ts

@@ -373,6 +373,11 @@ export * from './src/housing-context.js';
 export * from './src/hiring-context.js';
 export * from './src/housing-intent.js';
 export * from './src/housing-structured.js';
+export * from './src/housing-safety.js';
+export * from './src/housing-title.js';
+export * from './src/housing-language.js';
+export * from './src/housing-features.js';
+export * from './src/housing-listing-fields.js';
 
 // housing semantic helper declarations added in 0.2.5
 export function resolveHousingOccupancy(value: unknown): 'wholeProperty' | 'room' | 'sharedRoom' | 'bedSpace' | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Shared deterministic multilingual parsing lexicon for Whiteslove housing and hiring services",
   "repository": {
     "type": "git",
@@ -41,6 +41,11 @@
     "./housing-context": { "types": "./src/housing-context.d.ts", "import": "./src/housing-context.js" },
     "./housing-address": { "types": "./src/housing-address.d.ts", "import": "./src/housing-address.js" },
     "./housing-structured": { "types": "./src/housing-structured.d.ts", "import": "./src/housing-structured.js" },
+    "./housing-safety": { "types": "./src/housing-safety.d.ts", "import": "./src/housing-safety.js" },
+    "./housing-title": { "types": "./src/housing-title.d.ts", "import": "./src/housing-title.js" },
+    "./housing-language": { "types": "./src/housing-language.d.ts", "import": "./src/housing-language.js" },
+    "./housing-features": { "types": "./src/housing-features.d.ts", "import": "./src/housing-features.js" },
+    "./housing-listing-fields": { "types": "./src/housing-listing-fields.d.ts", "import": "./src/housing-listing-fields.js" },
     "./housing-text": { "types": "./src/housing-text.d.ts", "import": "./src/housing-text.js" },
     "./housing-source-aliases": { "types": "./src/housing-source-aliases.d.ts", "import": "./src/housing-source-aliases.js" },
     "./hiring": "./src/hiring.js",

package/src/housing-features.d.ts

@@ -0,0 +1,8 @@
+export type HousingFeatures = Readonly<{
+  internet: boolean | null;
+  courtyard: boolean | null;
+  gazebo: boolean | null;
+  petsAllowed: boolean | null;
+}>;
+
+export function parseHousingFeatures(value: unknown): HousingFeatures;

package/src/housing-language.d.ts

@@ -0,0 +1,4 @@
+export type HousingTextLanguage = 'ru' | 'uk' | 'en' | 'uz';
+
+export function housingTextIsInLanguage(value: unknown, language: string): boolean;
+export function detectHousingTextLanguage(value: unknown): HousingTextLanguage | null;

package/src/housing-language.js

@@ -0,0 +1,73 @@
+import { normalizeUnicode } from './normalization.js';
+
+// Uzbek and Kazakh Cyrillic carry letters no Slavic alphabet uses. Their
+// presence rules out "this text is already Russian/Ukrainian" even though the
+// housing vocabulary overlaps heavily. `і` is deliberately absent: it is an
+// ordinary Ukrainian letter.
+const NON_SLAVIC_CYRILLIC = /[ўқғҳәөүұңһ]/iu;
+const SLAVIC_LANGUAGES = new Set(['ru', 'uk']);
+
+/**
+ * Housing vocabulary that reliably indicates the language a listing body is
+ * written in. Deliberately common words: the goal is deciding whether a reader
+ * needs a translation, not identifying rare dialects.
+ */
+const HOUSING_LANGUAGE_SIGNALS = Object.freeze({
+  ru: {
+    pattern: /(?:квартир\p{L}*|комнат\p{L}*|этаж\p{L}*|дом\p{L}*|цен\p{L}*|сда[её]тся|прода[её]тся|аренд\p{L}*|рядом|метро|семейн\p{L}*|коммунальн\p{L}*|ремонт\p{L}*|мебел\p{L}*|балкон\p{L}*|район\p{L}*)/giu,
+    minimum: 2,
+  },
+  uk: {
+    pattern: /(?:квартир\p{L}*|кімнат\p{L}*|поверх\p{L}*|будинк\p{L}*|цін\p{L}*|здається|продається|оренд\p{L}*|поруч|метро|сімейн\p{L}*|комунальн\p{L}*|ремонт\p{L}*|меблі\p{L}*|балкон\p{L}*|район\p{L}*)/giu,
+    minimum: 2,
+  },
+  en: {
+    pattern: /(?:^|[^\p{L}])(?:apartment|flat|house|room|bedroom|floor|price|rent|rental|sale|family|utilities|near|available|furnished|balcony|district|deposit)(?=$|[^\p{L}])/giu,
+    minimum: 3,
+  },
+  uz: {
+    pattern: /(?:kvartira\p{L}*|xona\p{L}*|qavat\p{L}*|uy\p{L}*|narx\p{L}*|ijara\p{L}*|beriladi|sotiladi|yaqin|metro|mebel\p{L}*|balkon\p{L}*|tuman\p{L}*)/giu,
+    minimum: 2,
+  },
+});
+
+function signalCount(text, language) {
+  const signal = HOUSING_LANGUAGE_SIGNALS[language];
+  if (!signal) return 0;
+  return (text.match(signal.pattern) || []).length;
+}
+
+/**
+ * True when the housing text already reads as the given language, i.e. a reader
+ * of that language does not need it translated.
+ *
+ * Uses a per-language evidence threshold rather than a single hit, because one
+ * shared word ("metro", "balkon") appears across all of these languages.
+ */
+export function housingTextIsInLanguage(value, language) {
+  const text = normalizeUnicode(value ?? '').toLocaleLowerCase();
+  if (!text.trim()) return false;
+  const signal = HOUSING_LANGUAGE_SIGNALS[language];
+  if (!signal) return false;
+  // Uzbek/Kazakh Cyrillic text reuses Slavic housing words but is neither.
+  if (SLAVIC_LANGUAGES.has(language) && NON_SLAVIC_CYRILLIC.test(text)) return false;
+  return signalCount(text, language) >= signal.minimum;
+}
+
+/**
+ * Best-guess language of a housing text, or null when no language reaches its
+ * evidence threshold.
+ */
+export function detectHousingTextLanguage(value) {
+  const text = normalizeUnicode(value ?? '').toLocaleLowerCase();
+  if (!text.trim()) return null;
+
+  let best = null;
+  for (const language of Object.keys(HOUSING_LANGUAGE_SIGNALS)) {
+    if (SLAVIC_LANGUAGES.has(language) && NON_SLAVIC_CYRILLIC.test(text)) continue;
+    const count = signalCount(text, language);
+    if (count < HOUSING_LANGUAGE_SIGNALS[language].minimum) continue;
+    if (!best || count > best.count) best = { language, count };
+  }
+  return best?.language ?? null;
+}

package/src/housing-listing-fields.d.ts

@@ -0,0 +1,49 @@
+export type HousingMinRentTerm = Readonly<{
+  value: number;
+  unit: 'day' | 'week' | 'month' | 'year';
+}>;
+
+export type HousingUtilitiesAmount = Readonly<{
+  amount: number;
+  currency: string | null;
+  approximate: boolean;
+}>;
+
+export type HousingListingFields = Readonly<{
+  bedrooms: number | null;
+  bathrooms: number | null;
+  buildingYear: number | null;
+  balcony: boolean | null;
+  terrace: boolean | null;
+  privateYard: boolean | null;
+  courtyard: boolean | null;
+  gazebo: boolean | null;
+  dishwasher: boolean | null;
+  airConditioner: boolean | null;
+  gas: boolean | null;
+  newBuilding: boolean | null;
+  communalSeparated: boolean | null;
+  parking: boolean | null;
+  elevator: boolean | null;
+  heating: boolean | null;
+  hotWater: boolean | null;
+  internet: boolean | null;
+  petsAllowed: boolean | null;
+  childrenAllowed: boolean | null;
+  smokingAllowed: boolean | null;
+  negotiable: boolean | null;
+  furnished: boolean | null;
+  depositRequired: boolean | null;
+  firstRent: boolean | null;
+  minRentTerm: HousingMinRentTerm | null;
+  availableFrom: string | null;
+  utilitiesAmount: HousingUtilitiesAmount | null;
+}>;
+
+/**
+ * Empty input yields an empty object, so every field is optional on the result.
+ */
+export function parseHousingListingFields(
+  value: unknown,
+  options?: { country?: string },
+): Readonly<Partial<HousingListingFields>>;

package/src/housing-safety.d.ts

@@ -0,0 +1,7 @@
+export type HousingSafetySignals = Readonly<{
+  roomOnly: boolean;
+  singleFemaleTenantSought: boolean;
+}>;
+
+export function seeksSingleFemaleTenant(value: unknown): boolean;
+export function parseHousingSafetySignals(value: unknown): HousingSafetySignals;

package/src/housing-safety.js

@@ -0,0 +1,75 @@
+import { deepFreeze } from './lexicon-core.js';
+import { normalizeUnicode } from './normalization.js';
+import { isRoomOnlyHousing } from './housing-source-aliases.js';
+
+// Clause-scoped gap: the demand and the person must sit in the same sentence.
+// Crossing `.`/`!`/`?`/newline let "Ищу жильё. Одна девушка уже живёт" read as a
+// demand for one woman, which it is not.
+const CLAUSE = String.raw`[^\r\n.!?]`;
+
+/**
+ * Wording that seeks exactly one female tenant, as opposed to the generic
+ * "women only" audience wording that ordinary women-only listings use.
+ * The count matters: a landlord addressing one specific woman is the signal,
+ * not a flat that happens to prefer female tenants.
+ */
+const SINGLE_FEMALE_TENANT_PATTERNS = Object.freeze([
+  // ru: "только одна девушка", "нужна 1 девушка", "ищу одну женщину", "подселю одну девушку"
+  new RegExp(
+    String.raw`(?:только|лише|нужн\p{L}*|потрібн\p{L}*|ищ[еуy]\p{L}*|шука\p{L}*|подсел\p{L}*|підсел\p{L}*)`
+    + CLAUSE + `{0,24}`
+    + String.raw`(?:^|[^\p{L}\p{N}_])(?:одн(?:а|ої|ой|у|ту)|1)\s+(?:девушк\p{L}*|дівчин\p{L}*|женщин\p{L}*|жінк\p{L}*)`,
+    'iu',
+  ),
+  // uk/ru reversed order: "одна девушка нужна"
+  new RegExp(
+    String.raw`(?:^|[^\p{L}\p{N}_])(?:одн(?:а|ої|ой|у)|1)\s+(?:девушк\p{L}*|дівчин\p{L}*|женщин\p{L}*|жінк\p{L}*)`
+    + CLAUSE + `{0,18}`
+    + String.raw`(?:нужн\p{L}*|потрібн\p{L}*|треба|ищ[еуy]\p{L}*|шука\p{L}*)`,
+    'iu',
+  ),
+  // uzLatn: "faqat 1 ta qiz kerak", "bitta ayol ijarachi kerak"
+  new RegExp(
+    String.raw`(?:faqat\s+)?(?:^|[^\p{L}\p{N}_])(?:1|bitta)\s*(?:ta\s*)?(?:qiz|ayol)`
+    + CLAUSE + `{0,18}`
+    + String.raw`(?:ijarachi\s*)?(?:kerak|kere|kerakli)`,
+    'iu',
+  ),
+  // uzCyrl: "фақат 1 та қиз керак"
+  new RegExp(
+    String.raw`(?:фақат\s+)?(?:^|[^\p{L}\p{N}_])(?:1|битта)\s*(?:та\s*)?(?:қиз|аёл)`
+    + CLAUSE + `{0,18}`
+    + String.raw`(?:ижарачи\s*)?(?:керак|керакли)`,
+    'iu',
+  ),
+]);
+
+/**
+ * True when the text asks for exactly one female tenant.
+ *
+ * Deliberately narrower than the `women` audience: "только для девушек" is an
+ * ordinary preference and must not match, while "нужна одна девушка" does.
+ */
+export function seeksSingleFemaleTenant(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text.trim()) return false;
+  return SINGLE_FEMALE_TENANT_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+/**
+ * Linguistic safety signals for a housing listing.
+ *
+ * This reports only what the wording says. Whether a given combination is
+ * treated as a risk — and any price policy applied on top — belongs to the
+ * consuming service, not to the lexicon.
+ */
+export function parseHousingSafetySignals(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text.trim()) {
+    return deepFreeze({ roomOnly: false, singleFemaleTenantSought: false });
+  }
+  return deepFreeze({
+    roomOnly: isRoomOnlyHousing(text),
+    singleFemaleTenantSought: seeksSingleFemaleTenant(text),
+  });
+}

package/src/housing-title.d.ts

@@ -0,0 +1,2 @@
+export function isGenericHousingTitle(value: unknown): boolean;
+export function hasMeaningfulHousingTitle(value: unknown): boolean;

package/src/housing-title.js

@@ -0,0 +1,70 @@
+import { normalizeUnicode } from './normalization.js';
+
+/**
+ * Marketplace category headings that some sources (notably OLX) hand back in
+ * place of a real listing title. They name a whole search category rather than
+ * one property, so a consumer must not present them as the listing's own title.
+ *
+ * The English forms already embed the subject ("long-term apartment rentals"),
+ * so the subject is matched as an optional trailing word rather than required.
+ */
+const CATEGORY = String.raw`(?:`
+  + String.raw`(?:довгостроков\p{L}*|долгосрочн\p{L}*|короткостроков\p{L}*|краткосрочн\p{L}*|подобов\p{L}*|посуточн\p{L}*)\s+(?:оренда|аренда|найм)`
+  + String.raw`|(?:оренда|аренда|найм|продаж|продажа)`
+  + String.raw`|(?:long|short)[- ]?term\s+(?:apartment\s+|flat\s+|house\s+|room\s+)?rentals?`
+  + String.raw`|(?:apartments?|flats?|houses?|rooms?)\s+for\s+(?:rent|sale)`
+  + String.raw`|rentals?|daily\s+rentals?`
+  + String.raw`|ijaraga\s+berish|ijara|sotuvi`
+  + String.raw`)`;
+
+const SUBJECT = String.raw`(?:`
+  + String.raw`квартир\p{L}*|кімнат\p{L}*|комнат\p{L}*|будинк\p{L}*|будинків|дом\p{L}*|житл\p{L}*|нерухомост\p{L}*|недвижимост\p{L}*`
+  + String.raw`|apartments?|flats?|houses?|rooms?|property|real\s+estate`
+  + String.raw`|kvartira\p{L}*|uylar|xona\p{L}*`
+  + String.raw`)`;
+
+// Only a single trailing locality clause counts as part of the heading — one
+// short comma- or dash-separated fragment such as ", Подільський район".
+// Anything richer means the title is saying something about this property.
+const LOCALITY_TAIL = String.raw`(?:\s*[,–—-]\s*[^\r\n,]{1,40})?`;
+
+const GENERIC_TITLE_PATTERN = new RegExp(
+  `^\\s*${CATEGORY}(?:\\s+${SUBJECT})?${LOCALITY_TAIL}\\s*$`,
+  'iu',
+);
+
+// Digits are the cheapest proof a title says something specific: a room count,
+// an area, a price or a street number. "2-к квартира, 54 м²" is a real title
+// even though it opens with the same words as the category heading.
+const SPECIFIC_DETAIL = /\d/u;
+
+function titleContent(value) {
+  return normalizeUnicode(value ?? '')
+    .replace(
+      /[\p{Extended_Pictographic}\p{Emoji_Presentation}\p{Emoji_Modifier}\p{Variation_Selector}\p{Join_Control}]/gu,
+      '',
+    )
+    .replace(/[^\p{L}\p{N}]+/gu, '');
+}
+
+/**
+ * True when the title is a marketplace category heading rather than a title
+ * describing this specific property.
+ */
+export function isGenericHousingTitle(value) {
+  const text = normalizeUnicode(value ?? '').replace(/\s+/g, ' ').trim();
+  if (!text) return false;
+  if (SPECIFIC_DETAIL.test(text)) return false;
+  return GENERIC_TITLE_PATTERN.test(text);
+}
+
+/**
+ * True when the title can stand on its own in a listing card or popup.
+ *
+ * Rejects titles carrying almost no letters or digits (emoji- or
+ * punctuation-only) as well as marketplace category headings.
+ */
+export function hasMeaningfulHousingTitle(value) {
+  if (titleContent(value).length < 3) return false;
+  return !isGenericHousingTitle(value);
+}

package/src/index.js

@@ -36,6 +36,9 @@ export * from './housing-context.js';
 export * from './housing-address.js';
 export * from './housing-features.js';
 export * from './housing-listing-fields.js';
+export * from './housing-safety.js';
+export * from './housing-title.js';
+export * from './housing-language.js';
 export * from './housing-structured.js';
 export * from './hiring.js';
 export * from './hiring-languages.js';