text-to-map 1.0.2 → 1.0.4

package/dist/bin/address-points.js

@@ -1,6 +1,6 @@
-import { downloadAndImportAllLatestAddressPoints } from "../open-data-sync/address-points";
+import { downloadAndImportAddressPoints } from "../open-data-sync/address-points";
 console.time("downloadAndImportAllLatestAddressPoints");
-downloadAndImportAllLatestAddressPoints({})
+downloadAndImportAddressPoints()
     .then(() => {
     console.timeEnd("downloadAndImportAllLatestAddressPoints");
 })

package/dist/bin/regions.js

@@ -0,0 +1,8 @@
+import { downloadAndImportRegions } from "../open-data-sync/regions";
+downloadAndImportRegions()
+    .then(() => {
+    console.log("Completed");
+})
+    .catch((error) => {
+    console.log(error);
+});

package/dist/bin/schools.js

@@ -1,5 +1,5 @@
-import { downloadAndImportAllSchools } from "../open-data-sync/schools";
-downloadAndImportAllSchools({})
+import { downloadAndImportSchools } from "../open-data-sync/schools";
+downloadAndImportSchools({ tmpDir: "tmp" })
     .then(() => {
     console.log("Completed");
 })

package/dist/bin/streets.js

@@ -1,6 +1,6 @@
-import { downloadAndImportAllStreets } from "../open-data-sync/streets";
+import { downloadAndImportStreets } from "../open-data-sync/streets";
 console.time("downloadAndImportAllStreets");
-downloadAndImportAllStreets({})
+downloadAndImportStreets({})
     .then(() => {
     console.timeEnd("downloadAndImportAllStreets");
 })

package/dist/db/address-points.d.ts

@@ -26,6 +26,7 @@ export declare const commitAddressPoints: () => number;
 export declare const insertCities: (buffer: string[][]) => number;
 export declare const insertDistricts: (buffer: string[][]) => number;
 export declare const insertMunicipalityParts: (buffer: string[][]) => number;
+export declare const insertPragueDistricts: (buffer: string[][]) => number;
 export declare const insertStreets: (buffer: string[][]) => number;
 export declare const getAddressPointById: (addressPointId: number) => AddressPoint | null;
 export declare const checkStreetExists: (streetName: string, founder: Founder) => {

package/dist/db/address-points.js

@@ -1,10 +1,10 @@
-import { extractKeyValuesPairs, getDb, insertMultipleRows, nonEmptyOrNull, } from "./db";
 import jtsk2wgs84 from "@arodax/jtsk2wgs84";
-import { AddressPointType, isNegativeSeriesSpec, isRange, isSeriesSpecArray, isWholeMunicipalitySmdLine, SeriesType, } from "../street-markdown/types";
-import { MunicipalityType } from "./types";
+import { AddressPointType, createSingleLineAddress } from "czech-address";
+import { SeriesType, isNegativeSeriesSpec, isRange, isSeriesSpecArray, isWholeMunicipalitySmdLine, } from "../street-markdown/types";
 import { findClosestString } from "../utils/helpers";
+import { extractKeyValuesPairs, generate2DPlaceholders, getDb, insertMultipleRows, nonEmptyOrNull, } from "./db";
 import { getFounderCityCode } from "./founders";
-import { buildInline } from "../utils/addressBuilder";
+import { MunicipalityType } from "./types";
 const buffer = [];
 const MaxBufferSize = 1000;
 const DescriptiveType = "č.p.";
@@ -49,12 +49,11 @@ export const commitAddressPoints = () => {
     insertDistricts(buffer);
     insertMunicipalityParts(buffer);
     insertStreets(buffer);
+    insertPragueDistricts(buffer);
     const db = getDb();
-    const placeHolders = new Array(buffer.length)
-        .fill("(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
-        .join(", ");
+    const placeHolders = generate2DPlaceholders(15, buffer.length);
     const insertStatement = db.prepare(`INSERT OR IGNORE INTO address_point
-      (id, street_code, object_type_id, descriptive_number, orientational_number, orientational_number_letter, city_code, city_district_code, municipality_part_code, postal_code, jtsk_x, jtsk_y, wgs84_latitude, wgs84_longitude)
+      (id, street_code, object_type_id, descriptive_number, orientational_number, orientational_number_letter, city_code, city_district_code, municipality_part_code, prague_district_code, postal_code, jtsk_x, jtsk_y, wgs84_latitude, wgs84_longitude)
       VALUES ${placeHolders}`);
     const params = [];
     buffer.forEach((data) => {
@@ -65,7 +64,7 @@ export const commitAddressPoints = () => {
             const { lat, lon } = jtsk2wgs84(parseFloat(data[Column.xCoordinate]), parseFloat(data[Column.yCoordinate]));
             [latOrNull, lonOrNull] = [lat.toString(), lon.toString()];
         }
-        params.push(data[Column.admCode], nonEmptyOrNull(data[Column.streetCode]), ObjectTypes[data[Column.objectType]], nonEmptyOrNull(data[Column.houseNumber]), nonEmptyOrNull(data[Column.orientationalNumber]), nonEmptyOrNull(data[Column.orientationalNumberLetter]), data[Column.cityCode], nonEmptyOrNull(data[Column.districtCode]), nonEmptyOrNull(data[Column.municipalityPartCode]), data[Column.postalCode], nonEmptyOrNull(data[Column.xCoordinate]), nonEmptyOrNull(data[Column.yCoordinate]), latOrNull, lonOrNull);
+        params.push(data[Column.admCode], nonEmptyOrNull(data[Column.streetCode]), ObjectTypes[data[Column.objectType]], nonEmptyOrNull(data[Column.houseNumber]), nonEmptyOrNull(data[Column.orientationalNumber]), nonEmptyOrNull(data[Column.orientationalNumberLetter]), data[Column.cityCode], nonEmptyOrNull(data[Column.districtCode]), nonEmptyOrNull(data[Column.municipalityPartCode]), nonEmptyOrNull(data[Column.pragueDistrictCode]), data[Column.postalCode], nonEmptyOrNull(data[Column.xCoordinate]), nonEmptyOrNull(data[Column.yCoordinate]), latOrNull, lonOrNull);
     });
     buffer.length = 0;
     return insertStatement.run(params).changes;
@@ -84,6 +83,11 @@ export const insertMunicipalityParts = (buffer) => {
         Column.municipalityPartName,
     ]), "municipality_part", ["code", "name"]);
 };
+export const insertPragueDistricts = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.pragueDistrictCode, [
+        Column.pragueDistrictName,
+    ]), "prague_district", ["code", "name"]);
+};
 export const insertStreets = (buffer) => {
     return insertMultipleRows(extractKeyValuesPairs(buffer, Column.streetCode, [
         Column.cityCode,
@@ -93,13 +97,14 @@ export const insertStreets = (buffer) => {
 const addressPointSelect = `
   SELECT a.id, s.name AS street_name, o.name AS object_type_name, a.descriptive_number,
         a.orientational_number, a.orientational_number_letter, c.name AS city_name,
-        m.name AS municipality_part_name, d.name AS district_name, a.postal_code,
-        a.wgs84_latitude, a.wgs84_longitude
+        m.name AS municipality_part_name, p.name AS prague_district_name,
+        d.name AS district_name, a.postal_code, a.wgs84_latitude, a.wgs84_longitude
   FROM address_point a
   LEFT JOIN street s ON a.street_code = s.code
   INNER JOIN object_type o ON o.id = a.object_type_id
   INNER JOIN city c ON c.code = a.city_code
   LEFT JOIN city_district d ON a.city_district_code = d.code
+  LEFT JOIN prague_district p ON a.prague_district_code = p.code
   LEFT JOIN municipality_part m ON a.municipality_part_code = m.code`;
 export const getAddressPointById = (addressPointId) => {
     const db = getDb();
@@ -168,15 +173,16 @@ export const findAddressPoints = (smdLine, municipality) => {
         : "JOIN street s ON a.street_code = s.code AND s.name = ? COLLATE NOCASE";
     const statement = db.prepare(`
     SELECT a.id, s.name AS street_name, o.name AS object_type_name, a.descriptive_number,
-          a.orientational_number, a.orientational_number_letter, c.name AS city_name,
-          m.name AS municipality_part_name, d.name AS district_name, a.postal_code,
-          a.wgs84_latitude, a.wgs84_longitude
+      a.orientational_number, a.orientational_number_letter, c.name AS city_name,
+      d.name AS district_name, m.name AS municipality_part_name, p.name AS prague_district_name,
+      a.postal_code, a.wgs84_latitude, a.wgs84_longitude
     FROM address_point a
     ${streetJoinCondition}
     INNER JOIN object_type o ON o.id = a.object_type_id
     INNER JOIN city c ON c.code = a.city_code
     LEFT JOIN city_district d ON a.city_district_code = d.code
     LEFT JOIN municipality_part m ON a.municipality_part_code = m.code
+    LEFT JOIN prague_district p ON a.prague_district_code = p.code
     WHERE ${getMunicipalityWhere("a", municipality)}`);
     const params = isWholeMunicipalitySmdLine(smdLine)
         ? [municipality.code]
@@ -252,8 +258,7 @@ export const fitsType = (number, type) => {
         (type === SeriesType.Even && number % 2 === 0));
 };
 export const equalsFullStreetNumber = (fullStreetNumber, addressPoint) => {
-    return (fullStreetNumber.descriptiveNumber.number ===
-        addressPoint.descriptiveNumber &&
+    return (fullStreetNumber.descriptiveNumber.number === addressPoint.houseNumber &&
         fullStreetNumber.orientationalNumber.number ===
             addressPoint.orientationalNumber &&
         ((!fullStreetNumber.orientationalNumber.letter &&
@@ -264,7 +269,7 @@ export const equalsFullStreetNumber = (fullStreetNumber, addressPoint) => {
 const getNumberByType = (type, addressPoint) => {
     var _a;
     return type === SeriesType.Descriptive
-        ? addressPoint.descriptiveNumber
+        ? addressPoint.houseNumber
         : (_a = addressPoint.orientationalNumber) !== null && _a !== void 0 ? _a : null;
 };
 const getMunicipalityWhere = (alias, municipality) => {
@@ -272,22 +277,16 @@ const getMunicipalityWhere = (alias, municipality) => {
         ? `${alias}.city_code = ?`
         : `${alias}.city_district_code = ?`;
 };
-const createAddress = (result) => {
-    var _a;
-    const orientationalPart = result.orientational_number
-        ? `/${result.orientational_number}${(_a = result.orientational_number_letter) !== null && _a !== void 0 ? _a : ""}`
-        : "";
-    return `${result.street_name} ${result.descriptive_number}${orientationalPart}, ${result.city_name}`;
-};
 const rowToAddressPoint = (row) => {
     const point = {
         id: row.id,
         address: "",
         type: row.object_type_name === DescriptiveType
-            ? AddressPointType.Descriptive
+            ? AddressPointType.Description
             : AddressPointType.Registration,
-        descriptiveNumber: row.descriptive_number,
+        houseNumber: row.descriptive_number,
         city: row.city_name,
+        municipalityPart: row.municipality_part_name,
         postalCode: row.postal_code,
         lat: row.wgs84_latitude,
         lng: row.wgs84_longitude,
@@ -304,9 +303,9 @@ const rowToAddressPoint = (row) => {
     if (row.district_name !== null) {
         point.district = row.district_name;
     }
-    if (row.municipality_part_name !== null) {
-        point.municipalityPart = row.municipality_part_name;
+    if (row.prague_district !== null) {
+        point.pragueDistrict = row.prague_district_name;
     }
-    point.address = buildInline(point);
+    point.address = createSingleLineAddress(point);
     return point;
 };

package/dist/db/db.d.ts

@@ -15,9 +15,11 @@ export declare const insertMultipleRows: (rows: string[][], table: string, colum
 /**
  * Insert a single row and return the autoincremented ID.
  */
-export declare const insertAutoincrementRow: (row: string[], table: string, columnNames: string[]) => number;
+export declare const insertAutoincrementRow: (row: string[], table: string, columnNames: string[]) => number | null;
 export declare const deleteMultipleRows: (keys: string[], table: string, keyColumnName: string) => void;
 export declare const clearDuplicates: (rows: string[][], table: string, columnNames: string[]) => string[][];
 export declare const disconnect: () => void;
+export declare const generatePlaceholders: (n: number) => string;
+export declare const generate2DPlaceholders: (inner: number, outer: number) => string;
 export declare const extractKeyValuesPairs: (array: string[][], keyIndex: number, valuesIndices: number[]) => string[][];
 export {};

package/dist/db/db.js

@@ -1,10 +1,13 @@
 import Database from "better-sqlite3";
 import { existsSync, copyFileSync } from "fs";
-import { join } from "path";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 let _db;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 const defaults = {
     filePath: "address_points.db",
-    initFilePath: join("src", "address_points_init.db"),
+    initFilePath: join(__dirname, "..", "address_points_init.db"),
     verbose: false,
 };
 export const setDbConfig = (config) => {
@@ -51,7 +54,8 @@ export const insertMultipleRows = (rows, table, columnNames, preventDuplicatesBy
 export const insertAutoincrementRow = (row, table, columnNames) => {
     const db = getDb();
     const insertStatement = db.prepare(`INSERT INTO ${table} (${columnNames.join(",")}) VALUES (${generatePlaceholders(columnNames.length)})`);
-    return Number(insertStatement.run(row).lastInsertRowid);
+    const result = insertStatement.run(row);
+    return result.changes === 1 ? Number(result.lastInsertRowid) : null;
 };
 export const deleteMultipleRows = (keys, table, keyColumnName) => {
     const db = getDb();
@@ -76,9 +80,12 @@ export const disconnect = () => {
 const generateRepetitiveString = (value, glue, n) => {
     return new Array(n).fill(value).join(glue);
 };
-const generatePlaceholders = (n) => {
+export const generatePlaceholders = (n) => {
     return generateRepetitiveString("?", ",", n);
 };
+export const generate2DPlaceholders = (inner, outer) => {
+    return generateRepetitiveString(`(${generatePlaceholders(inner)})`, ",", outer);
+};
 export const extractKeyValuesPairs = (array, keyIndex, valuesIndices) => {
     const object = array.reduce((acc, data) => {
         if (data[keyIndex]) {

package/dist/db/founders.js

@@ -1,6 +1,7 @@
-import { MunicipalityType } from "./types";
-import { getDb, insertAutoincrementRow, insertMultipleRows } from "./db";
-import { extractMunicipalityName, findClosestString } from "../utils/helpers";
+import { MunicipalityType, } from "./types";
+import { generatePlaceholders, getDb, insertAutoincrementRow, insertMultipleRows, } from "./db";
+import { extractMunicipalityName, findClosestString, sanitizeMunicipalityName, } from "../utils/helpers";
+import distance from "@turf/distance";
 const cityTypeCode = 261;
 const cityDistrictTypeCode = 263;
 export const insertFounders = (founders) => {
@@ -20,48 +21,53 @@ export const insertFounders = (founders) => {
     let insertedFounders = 0;
     const schoolFounderConnectionData = [];
     founders.forEach((founder) => {
+        var _a;
         if (founder.municipalityType !== MunicipalityType.City &&
             founder.municipalityType !== MunicipalityType.District) {
             return;
         }
-        const municipalityName = extractMunicipalityName(founder);
+        const extractedMunicipalityName = extractMunicipalityName(founder);
         // check if the extracted municipality name is the same as in all the schools' locations
-        let allEqual = true;
-        let municipalityCode = "";
+        let differingSchools = [];
+        let municipalityCode = -1;
         founder.schools.forEach((school) => {
             const result = (founder.municipalityType === MunicipalityType.City
                 ? selectCityStatement
                 : selectDistrictStatement).get(school.izo);
             if (!result) {
-                console.log(`izo: ${school.izo}, extracted: ${municipalityName}, RUIAN: UNDEFINED`);
-                allEqual = false;
+                console.log(`izo: ${school.izo}, extracted: ${extractedMunicipalityName}, RUIAN: UNDEFINED`);
+                differingSchools.push(school);
             }
             else {
                 const { name, code } = result;
-                municipalityCode = code;
-                if (name !== municipalityName) {
-                    console.log(`izo: ${school.izo}, extracted: ${municipalityName}, RUIAN: ${name}`);
-                    allEqual = false;
+                if (name !== extractedMunicipalityName) {
+                    console.log(`izo: ${school.izo}, extracted: ${extractedMunicipalityName}, RUIAN: ${name}`);
+                    differingSchools.push(school);
                 }
+                // store municipalityCode even if the names don't match, we will use it later
+                municipalityCode = parseInt(code);
             }
         });
-        if (!allEqual) {
-            // here we could try to find the correct municipality by searching for the name in the DB
-            // this would solve the case of one school in the whole Czech Republic that is located outside
-            // its founder municipality - too much work for now
-            return;
+        municipalityCode = fixFounderProblems(founder, municipalityCode, differingSchools, extractedMunicipalityName);
+        const cityDistrictCode = founder.municipalityType === MunicipalityType.District
+            ? municipalityCode.toString()
+            : null;
+        let cityCode = null;
+        if (founder.municipalityType === MunicipalityType.City) {
+            cityCode = (_a = municipalityCode === null || municipalityCode === void 0 ? void 0 : municipalityCode.toString()) !== null && _a !== void 0 ? _a : null;
+        }
+        else {
+            cityCode = getCityCodeByDistrictCode(municipalityCode).toString();
         }
         const founderId = insertAutoincrementRow([
-            founder.name,
+            sanitizeMunicipalityName(founder.name),
             founder.ico,
             String(founder.originalType),
-            founder.municipalityType === MunicipalityType.City
-                ? municipalityCode
-                : null,
-            founder.municipalityType === MunicipalityType.City
-                ? null
-                : municipalityCode,
+            cityCode,
+            cityDistrictCode,
         ], "founder", ["name", "ico", "founder_type_code", "city_code", "city_district_code"]);
+        // founder table has unique (name, ico) with on conflict ignore, so possibly
+        // the row has not been inserted
         if (founderId !== null) {
             insertedFounders++;
             founder.schools.forEach((school) => {
@@ -72,6 +78,105 @@ export const insertFounders = (founders) => {
     const insertedConnections = insertMultipleRows(schoolFounderConnectionData, "school_founder", ["school_izo", "founder_id"]);
     return insertedFounders + insertedConnections;
 };
+const fixFounderProblems = (founder, municipalityCode, differingSchools, extractedMunicipalityName) => {
+    if (differingSchools.length === 0 ||
+        differingSchools.length < founder.schools.length) {
+        return municipalityCode;
+    }
+    // either the school does not have a position (invalid RUIAN or missing building)
+    // or the school is not in the same municipality as the founder
+    const db = getDb();
+    // find all cities and their position with the same name as municipalityName
+    const municipalities = findMunicipalitiesAndPositionsByNameAndType(extractedMunicipalityName, founder.municipalityType);
+    // get one school position (if there are more schools, they should be close to each other)
+    const schoolPosition = db
+        .prepare(`SELECT a.wgs84_latitude, a.wgs84_longitude FROM school s
+        JOIN school_location l ON s.izo = l.school_izo
+        JOIN address_point a ON l.address_point_id = a.id
+        WHERE s.izo IN (${generatePlaceholders(differingSchools.length)})
+        LIMIT 1`)
+        .get(...differingSchools.map((school) => school.izo));
+    if (schoolPosition) {
+        if (municipalities.length === 0) {
+            if (municipalityCode === -1) {
+                console.log(`no municipality by name or by location found for ${founder.name}`);
+                return null;
+            }
+            else {
+                console.log("no municipality matching the extracted name, using the municipality from RUIAN code");
+            }
+        }
+        else if (municipalities.length === 1) {
+            console.log("using the only municipality found matching the extracted name");
+            return municipalities[0].code;
+        }
+        else {
+            // get code and position of the closest city
+            let lowestDistance = Number.MAX_SAFE_INTEGER;
+            let municipalityCode = null;
+            for (const municipality of municipalities) {
+                let municipalityDistance = distance([municipality.lat, municipality.lng], [schoolPosition.wgs84_latitude, schoolPosition.wgs84_longitude]);
+                if (municipalityDistance < lowestDistance) {
+                    lowestDistance = municipalityDistance;
+                    municipalityCode = municipality.code;
+                }
+            }
+            console.log("using the closest municipality matching the extracted name");
+            return municipalityCode;
+        }
+    }
+    else {
+        if (municipalities.length > 0) {
+            if (municipalities.length > 1) {
+                console.log(`using the first municipality matching the extracted name (${municipalities.length} matches) - possibly incorrect!`);
+            }
+            else {
+                console.log("using the only municipality found matching the extracted name");
+            }
+            return municipalities[0].code;
+        }
+        else {
+            console.log(`no municipality by name or by location found for ${founder.name}`);
+            return null;
+        }
+    }
+};
+const getCityCodeByDistrictCode = (districtCode) => {
+    const db = getDb();
+    const result = db
+        .prepare(`SELECT c.code FROM city_district d
+      JOIN city c ON d.city_code = c.code
+      WHERE d.code = ?
+      LIMIT 1`)
+        .get(districtCode);
+    if (result) {
+        return result.code;
+    }
+    else {
+        return null;
+    }
+};
+const findMunicipalitiesAndPositionsByNameAndType = (name, type) => {
+    const db = getDb();
+    return (type === MunicipalityType.City
+        ? db
+            .prepare(`SELECT c.name, c.code, a.wgs84_latitude, a.wgs84_longitude FROM city c
+            JOIN address_point a ON c.code = a.city_code
+            WHERE c.name = ?
+            GROUP BY c.code`)
+            .all(name)
+        : db
+            .prepare(`SELECT d.name, d.code, a.wgs84_latitude, a.wgs84_longitude FROM city_district d
+            JOIN address_point a ON d.code = a.city_district_code
+            WHERE d.name = ?
+            GROUP BY d.code`)
+            .all(name)).map((row) => ({
+        code: row.code,
+        type,
+        lat: row.wgs84_latitude,
+        lng: row.wgs84_longitude,
+    }));
+};
 export const findFounder = (name) => {
     const errors = [];
     const db = getDb();
@@ -127,18 +232,21 @@ const resultToFounder = (result) => {
         municipalityType: result.founder_type_code === cityTypeCode
             ? MunicipalityType.City
             : MunicipalityType.District,
-        cityOrDistrictCode: result.city_code || result.city_district_code,
+        cityOrDistrictCode: result.founder_type_code === cityTypeCode
+            ? result.city_code
+            : result.city_district_code,
         schools: getSchoolsByFounderId(parseInt(result.id)),
     };
 };
 const getSchoolsByFounderId = (founderId) => {
     const db = getDb();
-    const statement = db.prepare(`SELECT s.izo, s.name, s.capacity, sl.address_point_id FROM school s
+    const statement = db.prepare(`SELECT s.izo, s.redizo, s.name, s.capacity, sl.address_point_id FROM school s
     JOIN school_founder sf ON s.izo = sf.school_izo
     JOIN school_location sl ON s.izo = sl.school_izo
     WHERE sf.founder_id = ?`);
     return statement.all(founderId).map((row) => ({
         izo: String(row.izo),
+        redizo: String(row.redizo),
         name: String(row.name),
         capacity: parseInt(row.capacity),
         locations: [

package/dist/db/meta.d.ts

@@ -1,3 +1,5 @@
 /// <reference types="better-sqlite3" />
 export declare const getMetaValue: (key: string) => string | undefined;
 export declare const setMetaValue: (key: string, value: any) => import("better-sqlite3").RunResult;
+export declare const setCurrentDatetimeMetaValue: (key: string) => void;
+export declare const getDatetimeMetaValue: (key: string) => Date | undefined;

package/dist/db/meta.js

@@ -15,3 +15,13 @@ export const setMetaValue = (key, value) => {
         return statement.run(value.toString(), key);
     }
 };
+export const setCurrentDatetimeMetaValue = (key) => {
+    setMetaValue(key, new Date().toISOString());
+};
+export const getDatetimeMetaValue = (key) => {
+    const value = getMetaValue(key);
+    if (value === undefined) {
+        return undefined;
+    }
+    return new Date(value);
+};

package/dist/db/regions.d.ts

@@ -0,0 +1,23 @@
+export declare const Column: {
+    cityName: number;
+    cityCode: number;
+    cityType: number;
+    orpName: number;
+    orpCsuCode65: number;
+    orpRuianCode: number;
+    orpCityCode: number;
+    countyName: number;
+    countyCsuCode101Lau: number;
+    countyCsuCode109Nuts: number;
+    countyRuianCode: number;
+    regionName: number;
+    regionShortName: number;
+    regionCsuCode100: number;
+    regionCsuCode108Nuts: number;
+    regionRuianCode: number;
+};
+export declare const insertRegionsAndOrps: (data: string[][]) => number;
+export declare const insertRegions: (buffer: string[][]) => number;
+export declare const insertCounties: (buffer: string[][]) => number;
+export declare const insertOrps: (buffer: string[][]) => number;
+export declare const insertCities: (buffer: string[][]) => number;

package/dist/db/regions.js

@@ -0,0 +1,65 @@
+import { extractKeyValuesPairs, getDb, insertMultipleRows } from "./db";
+export const Column = {
+    cityName: 0,
+    cityCode: 1,
+    cityType: 2,
+    orpName: 9,
+    orpCsuCode65: 10,
+    orpRuianCode: 11,
+    orpCityCode: 12,
+    countyName: 13,
+    countyCsuCode101Lau: 14,
+    countyCsuCode109Nuts: 15,
+    countyRuianCode: 16,
+    regionName: 17,
+    regionShortName: 18,
+    regionCsuCode100: 19,
+    regionCsuCode108Nuts: 20,
+    regionRuianCode: 21,
+};
+export const insertRegionsAndOrps = (data) => {
+    let changes = 0;
+    changes += insertRegions(data);
+    changes += insertCounties(data);
+    changes += insertOrps(data);
+    // cities are most likely already inserted, but in case they're not,
+    // we need to insert them before updating them with region data
+    changes += insertCities(data);
+    const db = getDb();
+    const updateStatement = db.prepare(`UPDATE city SET
+      region_code = ?,
+      county_code = ?,
+      orp_code = ?
+    WHERE code = ?`);
+    data.forEach((data) => {
+        changes += updateStatement.run(data[Column.regionRuianCode], data[Column.countyRuianCode], data[Column.orpRuianCode], data[Column.cityCode]).changes;
+    });
+    return changes;
+};
+export const insertRegions = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.regionRuianCode, [
+        Column.regionName,
+        Column.regionShortName,
+        Column.regionCsuCode100,
+        Column.regionCsuCode108Nuts,
+    ]), "region", ["code", "name", "short_name", "csu_code_100", "csu_code_108_nuts"]);
+};
+export const insertCounties = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.countyRuianCode, [
+        Column.countyName,
+        Column.countyCsuCode101Lau,
+        Column.countyCsuCode109Nuts,
+        Column.regionRuianCode,
+    ]), "county", ["code", "name", "csu_code_101_lau", "csu_code_109_nuts", "region_code"]);
+};
+export const insertOrps = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.orpRuianCode, [
+        Column.orpName,
+        Column.orpCsuCode65,
+        Column.regionRuianCode,
+        Column.countyRuianCode,
+    ]), "orp", ["code", "name", "csu_code_65", "region_code", "county_code"]);
+};
+export const insertCities = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.cityCode, [Column.cityName]), "city", ["code", "name"]);
+};

package/dist/db/schools.d.ts

@@ -1,5 +1,5 @@
 import { School } from "./types";
-export declare const insertSchools: (schools: School[], doNotClearTable?: boolean) => number;
+export declare const insertSchools: (schools: School[]) => number;
 export declare const findSchool: (name: string, schools: School[]) => {
     school: School | null;
     errors: string[];

package/dist/db/schools.js

@@ -1,38 +1,28 @@
-import { getDb, insertMultipleRows } from "./db";
 import { findClosestString } from "../utils/helpers";
-export const insertSchools = (schools, doNotClearTable = false) => {
-    if (!doNotClearTable) {
-        const db = getDb();
-        db.exec("DELETE FROM school_location");
-        db.exec("DELETE FROM school_founder");
-        db.exec("DELETE FROM school_location");
-        db.exec("DELETE FROM founder");
-        db.exec("DELETE FROM school");
-        db.exec("DELETE FROM sqlite_sequence WHERE name='school_location' OR name='founder' OR name='school_founder'");
-    }
-    const insertedSchools = insertMultipleRows(schools.map((school) => [
+import { getDb, insertMultipleRows } from "./db";
+export const insertSchools = (schools) => {
+    const db = getDb();
+    const uniqueSchools = filterOutDuplicates(schools);
+    const existingIzo = db.prepare("SELECT izo FROM school").pluck().all();
+    const toInsert = uniqueSchools.filter((school) => !existingIzo.includes(school.izo));
+    const toUpdate = uniqueSchools.filter((school) => existingIzo.includes(school.izo));
+    toUpdate.forEach((school) => {
+        db.prepare("UPDATE school SET name = ?, capacity = ? WHERE izo = ?").run(school.name, school.capacity, school.izo);
+    });
+    const insertedSchools = insertMultipleRows(toInsert.map((school) => [
         school.izo,
+        school.redizo,
         school.name,
         school.capacity.toString(),
-    ]), "school", ["izo", "name", "capacity"]);
-    // const locations = schools.flatMap((school) => {
-    //   const uniqueAddressPoints = [
-    //     ...new Set(school.locations.map((location) => location.addressPointId)),
-    //   ];
-    //   return uniqueAddressPoints.map((addressPoint) => [
-    //     school.izo,
-    //     addressPoint.toString(),
-    //   ]);
-    // });
-    const locations = schools
+    ]), "school", ["izo", "redizo", "name", "capacity"]);
+    const locations = toInsert
         .filter((school) => school.locations.length > 0)
         .map((school) => [
         school.izo,
-        school.locations[0].addressPointId.toString(),
+        school.locations[0].addressPointId.toString(), // add only first location
     ]);
     let insertedLocations = 0;
-    // @todo prevent FK errors (address point might not exist, maybe even school?) - or maybe the DB wasn't fresh
-    // plus filter out duplicit locations (same address id + izo)
+    // plus filter out duplicate locations (same address id + izo)
     locations.forEach((location) => {
         try {
             insertedLocations += insertMultipleRows([location], "school_location", ["school_izo", "address_point_id"], false);
@@ -59,3 +49,11 @@ export const findSchool = (name, schools) => {
     errors.push(`No exact match for school "${name}", using "${bestMatch}" instead.`);
     return { school, errors };
 };
+const filterOutDuplicates = (schools) => {
+    const izoSet = new Set();
+    return schools.filter((school) => {
+        const duplicate = izoSet.has(school.izo);
+        izoSet.add(school.izo);
+        return !duplicate;
+    });
+};

package/dist/db/types.d.ts

@@ -6,6 +6,7 @@ export interface SchoolLocation {
 export interface School {
     name: string;
     izo: string;
+    redizo: string;
     capacity: number;
     locations: SchoolLocation[];
 }
@@ -22,10 +23,15 @@ export declare enum MunicipalityType {
     District = 1,
     Other = 2
 }
+export interface Position {
+    lat: number;
+    lng: number;
+}
 export interface Municipality {
     type: MunicipalityType;
     code: number;
 }
+export type MunicipalityWithPosition = Municipality & Position;
 export declare const founderToMunicipality: (founder: Founder) => Municipality;
 export interface DbfStreet {
     KOD: string;

package/dist/index.d.ts

@@ -1,4 +1,20 @@
-export { downloadAndImportAllLatestAddressPoints, importAllLatestAddressPoints, deleteDb } from "./open-data-sync/address-points";
-export { downloadAndImportAllSchools, deleteSchoolsXmlFile } from "./open-data-sync/schools";
-export { downloadAndImportAllStreets } from "./open-data-sync/streets";
-export { parseOrdinanceToAddressPoints } from "./street-markdown/smd";
+import { downloadAndImportAddressPoints, deleteDb } from "./open-data-sync/address-points";
+import { downloadAndImportRegions } from "./open-data-sync/regions";
+import { downloadAndImportSchools } from "./open-data-sync/schools";
+import { downloadAndImportStreets } from "./open-data-sync/streets";
+import { parseOrdinanceToAddressPoints } from "./street-markdown/smd";
+import { OpenDataSyncOptions } from "./utils/helpers";
+export * from "./street-markdown/types";
+/**
+ * Download and import all open data to SQLite DB. The DB file will be located
+ * in the `dataDir` folder.
+ * @param options Options for the sync
+ * @param syncStreets Streets sync takes around 1 hour, so it might be skipped.
+ * ```typescript
+ * import { downloadAndImportEverything } from "text-to-map";
+ *
+ * await downloadAndImportEverything({ tmpDir: "./tmp", dataDir: "./data" });
+ * ```
+ */
+export declare function downloadAndImportEverything(options?: OpenDataSyncOptions, syncStreets?: boolean): Promise<void>;
+export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, parseOrdinanceToAddressPoints, };

package/dist/index.js

@@ -1,4 +1,37 @@
-export { downloadAndImportAllLatestAddressPoints, importAllLatestAddressPoints, deleteDb } from "./open-data-sync/address-points";
-export { downloadAndImportAllSchools, deleteSchoolsXmlFile } from "./open-data-sync/schools";
-export { downloadAndImportAllStreets } from "./open-data-sync/streets";
-export { parseOrdinanceToAddressPoints } from "./street-markdown/smd";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { downloadAndImportAddressPoints, deleteDb, } from "./open-data-sync/address-points";
+import { downloadAndImportRegions } from "./open-data-sync/regions";
+import { downloadAndImportSchools } from "./open-data-sync/schools";
+import { downloadAndImportStreets } from "./open-data-sync/streets";
+import { parseOrdinanceToAddressPoints } from "./street-markdown/smd";
+export * from "./street-markdown/types";
+/**
+ * Download and import all open data to SQLite DB. The DB file will be located
+ * in the `dataDir` folder.
+ * @param options Options for the sync
+ * @param syncStreets Streets sync takes around 1 hour, so it might be skipped.
+ * ```typescript
+ * import { downloadAndImportEverything } from "text-to-map";
+ *
+ * await downloadAndImportEverything({ tmpDir: "./tmp", dataDir: "./data" });
+ * ```
+ */
+export function downloadAndImportEverything(options = {}, syncStreets = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield downloadAndImportAddressPoints(options);
+        yield downloadAndImportSchools(options);
+        yield downloadAndImportRegions(options);
+        if (syncStreets) {
+            yield downloadAndImportStreets(options);
+        }
+    });
+}
+export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, parseOrdinanceToAddressPoints, };

package/dist/open-data-sync/address-points.d.ts

@@ -1,4 +1,3 @@
 import { OpenDataSyncOptions } from "../utils/helpers";
-export declare const downloadAndImportAllLatestAddressPoints: (options?: OpenDataSyncOptions) => Promise<void>;
-export declare const importAllLatestAddressPoints: (options?: OpenDataSyncOptions) => Promise<void>;
+export declare const downloadAndImportAddressPoints: (options?: OpenDataSyncOptions) => Promise<void>;
 export declare const deleteDb: (options?: OpenDataSyncOptions) => void;

package/dist/open-data-sync/address-points.js

@@ -54,17 +54,13 @@ const importDataToDb = (options) => __awaiter(void 0, void 0, void 0, function*
     console.log(`Import completed. Total imported rows: ${total}`);
 });
 const getExtractionFolder = (options) => join(options.tmpDir, options.addressPointsCsvFolderName);
-export const downloadAndImportAllLatestAddressPoints = (options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+export const downloadAndImportAddressPoints = (options = {}) => __awaiter(void 0, void 0, void 0, function* () {
     const completeOptions = prepareOptions(options);
     const datasetFeedLink = yield getLatestUrlFromAtomFeed(completeOptions.addressPointsAtomUrl);
     const zipUrl = yield getLatestUrlFromAtomFeed(datasetFeedLink);
     yield downloadAndUnzip(zipUrl, completeOptions);
     yield importDataToDb(completeOptions);
 });
-export const importAllLatestAddressPoints = (options = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    const completeOptions = prepareOptions(options);
-    yield importDataToDb(completeOptions);
-});
 export const deleteDb = (options = {}) => {
     const completeOptions = prepareOptions(options);
     if (existsSync(completeOptions.dbFilePath)) {

package/dist/open-data-sync/regions.d.ts

@@ -0,0 +1,2 @@
+import { OpenDataSyncOptions } from "../utils/helpers";
+export declare const downloadAndImportRegions: (options?: OpenDataSyncOptions) => Promise<void>;

package/dist/open-data-sync/regions.js

@@ -0,0 +1,36 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { parse } from "csv-parse";
+import iconv from "iconv-lite";
+import fetch from "node-fetch";
+import { pipeline } from "stream/promises";
+import { initDb, prepareOptions, } from "../utils/helpers";
+import { insertRegionsAndOrps } from "../db/regions";
+const downloadAndImportDataToDb = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log("Downloading regions and ORP data...");
+    const response = yield fetch(options.regionsCsvUrl);
+    if (response.status !== 200) {
+        throw new Error(`The file could not be downloaded. HTTP Code: ${response.status}`);
+    }
+    console.log("Download completed. Starting to parse CSV file...");
+    const rows = [];
+    const parseStream = parse({ delimiter: ",", fromLine: 2 }).on("data", (data) => {
+        rows.push(data);
+    });
+    yield pipeline(response.body, iconv.decodeStream("utf-8"), parseStream);
+    console.log("Parsing completed. Starting to import data to DB...");
+    initDb(options);
+    insertRegionsAndOrps(rows);
+    console.log(`Import completed. Total imported rows: ${rows.length}`);
+});
+export const downloadAndImportRegions = (options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const completeOptions = prepareOptions(options);
+    yield downloadAndImportDataToDb(completeOptions);
+});

package/dist/open-data-sync/schools.d.ts

@@ -1,3 +1,3 @@
 import { OpenDataSyncOptions } from "../utils/helpers";
-export declare const downloadAndImportAllSchools: (options: OpenDataSyncOptions) => Promise<void>;
+export declare const downloadAndImportSchools: (options: OpenDataSyncOptions) => Promise<void>;
 export declare const deleteSchoolsXmlFile: (options?: OpenDataSyncOptions) => void;

package/dist/open-data-sync/schools.js

@@ -32,21 +32,23 @@ const downloadXml = (options) => __awaiter(void 0, void 0, void 0, function* ()
 var XMLState;
 (function (XMLState) {
     XMLState[XMLState["None"] = 0] = "None";
-    XMLState[XMLState["SchoolName"] = 1] = "SchoolName";
-    XMLState[XMLState["Izo"] = 2] = "Izo";
-    XMLState[XMLState["Ico"] = 3] = "Ico";
-    XMLState[XMLState["SchoolType"] = 4] = "SchoolType";
-    XMLState[XMLState["Capacity"] = 5] = "Capacity";
-    XMLState[XMLState["RuianCode"] = 6] = "RuianCode";
-    XMLState[XMLState["Address"] = 7] = "Address";
-    XMLState[XMLState["FounderName"] = 8] = "FounderName";
-    XMLState[XMLState["FounderType"] = 9] = "FounderType";
-    XMLState[XMLState["FounderIco"] = 10] = "FounderIco";
+    XMLState[XMLState["RedIzo"] = 1] = "RedIzo";
+    XMLState[XMLState["SchoolName"] = 2] = "SchoolName";
+    XMLState[XMLState["Izo"] = 3] = "Izo";
+    XMLState[XMLState["Ico"] = 4] = "Ico";
+    XMLState[XMLState["SchoolType"] = 5] = "SchoolType";
+    XMLState[XMLState["Capacity"] = 6] = "Capacity";
+    XMLState[XMLState["RuianCode"] = 7] = "RuianCode";
+    XMLState[XMLState["Address"] = 8] = "Address";
+    XMLState[XMLState["FounderName"] = 9] = "FounderName";
+    XMLState[XMLState["FounderType"] = 10] = "FounderType";
+    XMLState[XMLState["FounderIco"] = 11] = "FounderIco";
 })(XMLState || (XMLState = {}));
 const SCHOOL_TYPE_PRIMARY = "B00";
 const createNewSchool = () => {
     return {
         name: "",
+        redizo: "",
         izo: "",
         capacity: 0,
         locations: [],
@@ -91,6 +93,9 @@ const processSchoolRegisterXml = (options) => __awaiter(void 0, void 0, void 0,
                     isCurrentSchoolPrimary = false;
                     isRuianCodeMissing = false;
                     break;
+                case "RedIzo":
+                    state = XMLState.RedIzo;
+                    break;
                 case "RedPlnyNazev":
                     state = XMLState.SchoolName;
                     break;
@@ -191,6 +196,7 @@ const processSchoolRegisterXml = (options) => __awaiter(void 0, void 0, void 0,
                 case "MistoRUAINKod":
                     isRuianCodeMissing = !isRuianCodeSet;
                 case "RedPlnyNazev":
+                case "RedIzo":
                 case "ICO":
                 case "IZO":
                 case "SkolaDruhTyp":
@@ -208,6 +214,8 @@ const processSchoolRegisterXml = (options) => __awaiter(void 0, void 0, void 0,
         })
             .on("text", (text) => {
             switch (state) {
+                case XMLState.RedIzo:
+                    currentSchool.redizo = text;
                 case XMLState.SchoolName:
                     currentSchool.name = text;
                     break;
@@ -295,10 +303,11 @@ const importDataToDb = (options, saveFoundersToCsv = false, saveSchoolsWithoutRu
 const getXmlFilePath = (options) => {
     return join(options.tmpDir, options.schoolsXmlFileName);
 };
-export const downloadAndImportAllSchools = (options) => __awaiter(void 0, void 0, void 0, function* () {
+export const downloadAndImportSchools = (options) => __awaiter(void 0, void 0, void 0, function* () {
     const runOptions = prepareOptions(options);
     yield downloadXml(runOptions);
     yield importDataToDb(runOptions, false, true);
+    deleteSchoolsXmlFile(runOptions);
 });
 export const deleteSchoolsXmlFile = (options = {}) => {
     const runOptions = prepareOptions(options);

package/dist/open-data-sync/streets.d.ts

@@ -1,2 +1,2 @@
 import { OpenDataSyncOptions } from "../utils/helpers";
-export declare const downloadAndImportAllStreets: (options: OpenDataSyncOptions) => Promise<void>;
+export declare const downloadAndImportStreets: (options: OpenDataSyncOptions) => Promise<void>;

package/dist/open-data-sync/streets.js

@@ -39,13 +39,14 @@ const downloadZipAndParseDbfFile = (url, index, options) => __awaiter(void 0, vo
     rmSync(zipFilePath);
     return obj;
 });
-const importDataToDb = (data, options) => __awaiter(void 0, void 0, void 0, function* () {
+const importDataToDb = (data) => __awaiter(void 0, void 0, void 0, function* () {
     if (data.length === 0) {
         return;
     }
     insertStreetsFromDbf(data);
 });
-export const downloadAndImportAllStreets = (options) => __awaiter(void 0, void 0, void 0, function* () {
+export const downloadAndImportStreets = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log("Starting to download and import streets. This takes up to 1 hour.");
     const completeOptions = prepareOptions(options);
     initDb(completeOptions);
     prepareFolders(completeOptions);
@@ -69,7 +70,7 @@ export const downloadAndImportAllStreets = (options) => __awaiter(void 0, void 0
     for (const link of newLinks) {
         const zipLink = yield getLatestUrlFromAtomFeed(link);
         const dbfObject = yield downloadZipAndParseDbfFile(zipLink, done, completeOptions);
-        yield importDataToDb(dbfObject, completeOptions);
+        yield importDataToDb(dbfObject);
         setStreetAsSynced(link);
         done++;
         console.log(`Loaded links: ${done}/${allDatasetFeedLinks.length}`);

package/dist/street-markdown/types.d.ts

@@ -1,4 +1,5 @@
 import { Municipality as DbMunicipality } from "../db/types";
+import { AddressPoint as CzechAddressPoint } from "czech-address";
 export interface ProcessedSmdLines {
     smdLines: SmdLine[];
     errors: string[];
@@ -42,22 +43,9 @@ export declare enum SeriesType {
     All = 2,
     Descriptive = 3
 }
-export declare enum AddressPointType {
-    Descriptive = 0,
-    Registration = 1
-}
-export interface AddressPoint {
+export interface AddressPoint extends CzechAddressPoint {
     id: number;
     address: string;
-    type: AddressPointType;
-    street?: string;
-    descriptiveNumber: number;
-    orientationalNumber?: number;
-    orientationalNumberLetter?: string;
-    postalCode: string;
-    city: string;
-    district?: string;
-    municipalityPart?: string;
     lat: number;
     lng: number;
 }

package/dist/street-markdown/types.js

@@ -10,9 +10,4 @@ export var SeriesType;
     SeriesType[SeriesType["All"] = 2] = "All";
     SeriesType[SeriesType["Descriptive"] = 3] = "Descriptive";
 })(SeriesType || (SeriesType = {}));
-export var AddressPointType;
-(function (AddressPointType) {
-    AddressPointType[AddressPointType["Descriptive"] = 0] = "Descriptive";
-    AddressPointType[AddressPointType["Registration"] = 1] = "Registration";
-})(AddressPointType || (AddressPointType = {}));
 export const isAddressPoint = (something) => something.hasOwnProperty("id");

package/dist/utils/helpers.d.ts

@@ -12,6 +12,8 @@ export interface OpenDataSyncOptions {
     streetDbfFileName?: string;
     schoolsXmlUrl?: string;
     schoolsXmlFileName?: string;
+    regionsCsvUrl?: string;
+    regionsCsvFileName?: string;
 }
 export interface OpenDataSyncOptionsNotEmpty {
     tmpDir: string;
@@ -26,9 +28,12 @@ export interface OpenDataSyncOptionsNotEmpty {
     streetDbfFileName: string;
     schoolsXmlUrl: string;
     schoolsXmlFileName: string;
+    regionsCsvUrl: string;
+    regionsCsvFileName: string;
 }
 export declare const getAppDataDirPath: () => string;
 export declare const prepareOptions: (options: OpenDataSyncOptions) => OpenDataSyncOptionsNotEmpty;
 export declare const initDb: (options: OpenDataSyncOptionsNotEmpty) => void;
 export declare const extractMunicipalityName: (founder: Founder) => string;
+export declare const sanitizeMunicipalityName: (name: string) => string;
 export declare const findClosestString: (str: string, arr: string[]) => string;

package/dist/utils/helpers.js

@@ -1,15 +1,16 @@
 import { existsSync, mkdirSync } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
+import { dirname, join } from "path";
 import { MunicipalityType } from "../db/types";
 import { setDbConfig } from "../db/db";
+import { fileURLToPath } from "url";
 const appName = "text-to-map";
 export const getAppDataDirPath = () => join(process.env.APPDATA ||
     (process.platform == "darwin"
         ? process.env.HOME + "/Library/Preferences"
         : process.env.HOME + "/.local/share"), appName);
 export const prepareOptions = (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const dataDir = (_a = options.dataDir) !== null && _a !== void 0 ? _a : getAppDataDirPath();
     if (!existsSync(dataDir)) {
         mkdirSync(dataDir);
@@ -18,11 +19,13 @@ export const prepareOptions = (options) => {
     if (!existsSync(tmpAppDir)) {
         mkdirSync(tmpAppDir);
     }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
     return {
         tmpDir: (_b = options.tmpDir) !== null && _b !== void 0 ? _b : tmpAppDir,
         dataDir: dataDir,
         dbFilePath: (_c = options.dbFilePath) !== null && _c !== void 0 ? _c : join(dataDir, "address_points.db"),
-        dbInitFilePath: (_d = options.dbInitFilePath) !== null && _d !== void 0 ? _d : join("src", "address_points_init.db"),
+        dbInitFilePath: (_d = options.dbInitFilePath) !== null && _d !== void 0 ? _d : join(__dirname, "..", "address_points_init.db"),
         addressPointsAtomUrl: (_e = options.addressPointsAtomUrl) !== null && _e !== void 0 ? _e : "https://atom.cuzk.cz/RUIAN-CSV-ADR-ST/RUIAN-CSV-ADR-ST.xml",
         addressPointsZipFileName: (_f = options.addressPointsZipFileName) !== null && _f !== void 0 ? _f : "ruian_csv.zip",
         addressPointsCsvFolderName: (_g = options.addressPointsCsvFolderName) !== null && _g !== void 0 ? _g : "CSV",
@@ -31,6 +34,8 @@ export const prepareOptions = (options) => {
         streetDbfFileName: (_k = options.streetDbfFileName) !== null && _k !== void 0 ? _k : "UL_L.dbf",
         schoolsXmlUrl: (_l = options.schoolsXmlUrl) !== null && _l !== void 0 ? _l : "https://rejstriky.msmt.cz/opendata/vrejcelk.xml",
         schoolsXmlFileName: (_m = options.schoolsXmlFileName) !== null && _m !== void 0 ? _m : "school-register.xml",
+        regionsCsvUrl: (_o = options.regionsCsvUrl) !== null && _o !== void 0 ? _o : "https://www.czso.cz/documents/10180/23208674/struktura_uzemi_cr.csv",
+        regionsCsvFileName: (_p = options.regionsCsvFileName) !== null && _p !== void 0 ? _p : "struktura_uzemi_cr.csv",
     };
 };
 export const initDb = (options) => {
@@ -67,6 +72,12 @@ export const extractMunicipalityName = (founder) => {
     }
     return founder.name;
 };
+export const sanitizeMunicipalityName = (name) => {
+    return name
+        .replace(" - ", "-")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+};
 export const findClosestString = (str, arr) => {
     let closestStr = "";
     let closestDistance = Number.MAX_SAFE_INTEGER;

package/package.json

@@ -2,10 +2,12 @@
   "type": "module",
   "dependencies": {
     "@arodax/jtsk2wgs84": "^1.0.2",
+    "@turf/distance": "^6.5.0",
     "adm-zip": "^0.5.9",
     "better-sqlite3": "^8.0.1",
     "chevrotain": "^10.4.2",
     "csv-parse": "^5.3.3",
+    "czech-address": "^1.0.1",
     "feedparser": "^2.2.10",
     "iconv-lite": "^0.6.3",
     "node-fetch": "^3.3.0",
@@ -29,12 +31,12 @@
   },
   "scripts": {
     "address-points": "ts-node --experimental-specifier-resolution=node --esm src/bin/address-points.ts",
-    "address-points-import-only": "ts-node --experimental-specifier-resolution=node --esm src/bin/address-points-import-only.ts",
     "schools": "ts-node --experimental-specifier-resolution=node --esm src/bin/schools.ts",
     "clear-all": "ts-node --experimental-specifier-resolution=node --esm src/bin/clear-all.ts",
     "parse-ordinance": "ts-node --experimental-specifier-resolution=node --esm src/bin/parse-ordinance.ts",
     "diagrams": "ts-node --experimental-specifier-resolution=node --esm src/bin/generate-syntax-diagrams.ts",
     "streets": "ts-node --experimental-specifier-resolution=node --esm src/bin/streets.ts",
+    "regions": "ts-node --experimental-specifier-resolution=node --esm src/bin/regions.ts",
     "dbf": "ts-node --experimental-specifier-resolution=node --esm src/bin/dbf.ts",
     "test": "jest",
     "ordinance-to-csv-rules": "node src/smd-to-csv/ordinance-to-csv-rules.js",
@@ -47,7 +49,7 @@
   },
   "name": "text-to-map",
   "description": "Text To Map usiluje o lepší, strojově zpracovatelné využití částí vyhlášek s výčtem ulic a dalších lokací. Jde o rozšiřitelnou sadu konceptů a nástrojů, které zajistí hladký převod výčtu ulic a jejich rozsahů v lidsky srozumitelném jazyce do strojově zpracovatelného, uchopitelného formátu.",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/dist/bin/address-points-import-only.js

@@ -1,14 +0,0 @@
-import { importAllLatestAddressPoints } from "../open-data-sync/address-points";
-console.time("importOnly");
-importAllLatestAddressPoints({})
-    .then(() => {
-    console.timeEnd("importOnly");
-})
-    .catch((error) => {
-    if (error.hasOwnProperty("stack")) {
-        console.log(error, error.stack);
-    }
-    else {
-        console.log(error);
-    }
-});

package/dist/utils/addressBuilder.d.ts

@@ -1,8 +0,0 @@
-import { AddressPoint } from "../street-markdown/types";
-export interface ThreeRowsAddress {
-    firstRow: string;
-    secondRow: string;
-    thirdRow: string;
-}
-export declare const buildInline: (address: AddressPoint) => string;
-export declare const build: (address: AddressPoint) => ThreeRowsAddress;

package/dist/utils/addressBuilder.js

@@ -1,101 +0,0 @@
-/*
-  Taken from https://github.com/letomas/RUIAN-search and rewritten to typescript.
-
-MIT License
-
-Copyright (c) 2020 Tomáš Le
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-import { AddressPointType } from "../street-markdown/types";
-export const buildInline = (address) => {
-    const addressInRows = build(address);
-    let result = addressInRows.firstRow + ", " + addressInRows.secondRow;
-    if (addressInRows.thirdRow) {
-        result += ", " + addressInRows.thirdRow;
-    }
-    return result;
-};
-export const build = (address) => {
-    const result = {
-        firstRow: "",
-        secondRow: "",
-        thirdRow: "",
-    };
-    if (!!address.street && !districtEqualsCity(address)) {
-        result.secondRow = address.district;
-    }
-    if (!address.street) {
-        if (address.city === address.district) {
-            let buildingType = address.type === AddressPointType.Registration ? " č. ev. " : "č. p. ";
-            result.firstRow = buildingType + address.descriptiveNumber;
-        }
-        else {
-            result.firstRow = address.district;
-            result.firstRow += " " + buildHouseNumber(address);
-        }
-        result.firstRow += buildOrientationalNumber(address);
-        buildLastRow(result, address);
-        return result;
-    }
-    result.firstRow = address.street;
-    result.firstRow += " " + buildHouseNumber(address);
-    result.firstRow += buildOrientationalNumber(address);
-    buildLastRow(result, address);
-    return result;
-};
-const buildHouseNumber = (address) => {
-    if (address.type === AddressPointType.Registration) {
-        return "č. ev. " + address.descriptiveNumber;
-    }
-    return address.descriptiveNumber;
-};
-const buildOrientationalNumber = (address) => {
-    var _a;
-    if (address.orientationalNumber) {
-        return ("/" +
-            address.orientationalNumber +
-            ((_a = address.orientationalNumberLetter) !== null && _a !== void 0 ? _a : ""));
-    }
-    return "";
-};
-const buildLastRow = (result, address) => {
-    // if (!result.secondRow) {
-    //   if (address.city === "Praha") {
-    //     result.secondRow = address.postalCode + " " + address.pragueBoroughName;
-    //   } else {
-    //     result.secondRow = address.postalCode + " " + address.cityName;
-    //   }
-    // } else {
-    //   if (address.cityName === "Praha") {
-    //     result.thirdRow = address.postalCode + " " + address.pragueBoroughName;
-    //   } else {
-    //     result.thirdRow = address.postalCode + " " + address.cityName;
-    //   }
-    // }
-    if (!result.secondRow) {
-        result.secondRow = address.postalCode + " " + address.city;
-    }
-    else {
-        result.thirdRow = address.postalCode + " " + address.city;
-    }
-};
-const districtEqualsCity = (address) => {
-    return address.district === address.city;
-};