text-to-map 1.0.0

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

@@ -0,0 +1,308 @@
+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 { createReadStream, createWriteStream, existsSync, rmSync } from "fs";
+import { join } from "path";
+import sax from "sax";
+import fetch from "node-fetch";
+import { setDbConfig } from "../db/db";
+import { prepareOptions, } from "../utils/helpers";
+import { pipeline } from "stream/promises";
+import { MunicipalityType } from "../db/types";
+import { insertSchools } from "../db/schools";
+import { insertFounders } from "../db/founders";
+const downloadXml = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (existsSync(getXmlFilePath(options))) {
+        return;
+    }
+    console.log("Downloading a large XML file with school data...");
+    const response = yield fetch(options.schoolsXmlUrl);
+    if (response.status !== 200) {
+        throw new Error(`The XML file could not be downloaded. HTTP Code: ${response.status}`);
+    }
+    yield pipeline(response.body, createWriteStream(getXmlFilePath(options)));
+    console.log("Finished downloading.");
+});
+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 = {}));
+const SCHOOL_TYPE_PRIMARY = "B00";
+const createNewSchool = () => {
+    return {
+        name: "",
+        izo: "",
+        capacity: 0,
+        locations: [],
+    };
+};
+const getCorrectFounderType = (founderType) => {
+    return founderType === "" ? "101" : founderType;
+};
+const getMunicipalityType = (founderType) => {
+    return founderType === "261"
+        ? MunicipalityType.City
+        : founderType === "263"
+            ? MunicipalityType.District
+            : MunicipalityType.Other;
+};
+const processSchoolRegisterXml = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    let currentSchool;
+    let isCurrentSchoolPrimary;
+    let currentIzo;
+    let currentIco;
+    let currentType;
+    let currentCapacity;
+    let currentLocations = [];
+    let state = XMLState.None;
+    let currentFounders = [];
+    let currentFounderIco;
+    let currentFounderName;
+    let currentFounderType;
+    let isRuianCodeSet = false;
+    let isRuianCodeMissing = false;
+    let currentAddress = [];
+    const founders = new Map();
+    const schools = [];
+    const schoolsWithoutRuian = [];
+    const streamPromise = new Promise((resolve, reject) => {
+        const saxStream = sax
+            .createStream(true)
+            .on("opentag", (tag) => {
+            switch (tag.name) {
+                case "PravniSubjekt":
+                    currentSchool = createNewSchool();
+                    isCurrentSchoolPrimary = false;
+                    isRuianCodeMissing = false;
+                    break;
+                case "RedPlnyNazev":
+                    state = XMLState.SchoolName;
+                    break;
+                case "IZO":
+                    state = XMLState.Izo;
+                    break;
+                case "ICO":
+                    state = XMLState.Ico;
+                    break;
+                case "SkolaDruhTyp":
+                    state = XMLState.SchoolType;
+                    break;
+                case "SkolaKapacita":
+                    state = XMLState.Capacity;
+                    break;
+                case "MistoRUAINKod":
+                    isRuianCodeSet = false;
+                    currentAddress = [];
+                    state = XMLState.RuianCode;
+                    break;
+                case "ZrizNazev":
+                    state = XMLState.FounderName;
+                    break;
+                case "ZrizPravniForma":
+                    state = XMLState.FounderType;
+                    break;
+                case "MistoAdresa1":
+                case "MistoAdresa2":
+                case "MistoAdresa3":
+                    state = XMLState.Address;
+                    break;
+                case "ZrizDatumNarozeni":
+                case "ZrizICO":
+                    state = XMLState.FounderIco;
+                    break;
+            }
+        })
+            .on("closetag", (tagName) => {
+            switch (tagName) {
+                case "PravniSubjekt":
+                    if (isCurrentSchoolPrimary) {
+                        schools.push(currentSchool);
+                        currentFounders.forEach((founder) => {
+                            const key = founder.name + founder.ico;
+                            if (founders.has(key)) {
+                                founders.get(key).schools.push(currentSchool);
+                            }
+                            else {
+                                founders.set(key, {
+                                    name: founder.name,
+                                    ico: founder.ico,
+                                    originalType: founder.type,
+                                    municipalityType: getMunicipalityType(founder.type),
+                                    schools: [currentSchool],
+                                });
+                            }
+                        });
+                    }
+                    currentIco = "";
+                    currentFounders = [];
+                    break;
+                case "Zrizovatel":
+                    if (currentFounderIco === "" || currentFounderName === "") {
+                        currentFounders.push({
+                            ico: currentIco,
+                            name: currentSchool.name,
+                            type: "224", // s.r.o (not all are those, but we don't need to differentiate here)
+                        });
+                    }
+                    else {
+                        currentFounders.push({
+                            ico: currentFounderIco,
+                            name: currentFounderName,
+                            type: getCorrectFounderType(currentFounderType),
+                        });
+                    }
+                    currentFounderIco = "";
+                    currentFounderName = "";
+                    currentFounderType = "";
+                    break;
+                case "SkolaZarizeni":
+                    if (currentType === SCHOOL_TYPE_PRIMARY) {
+                        currentSchool.izo = currentIzo;
+                        currentSchool.locations = currentLocations;
+                        currentSchool.capacity = currentCapacity;
+                    }
+                    currentLocations = [];
+                    break;
+                case "SkolaMistoVykonuCinnosti":
+                    if (isRuianCodeMissing) {
+                        schoolsWithoutRuian.push({
+                            izo: currentIzo,
+                            address: currentAddress,
+                            isPrimary: currentType === SCHOOL_TYPE_PRIMARY,
+                        });
+                    }
+                    break;
+                case "MistoRUAINKod":
+                    isRuianCodeMissing = !isRuianCodeSet;
+                case "RedPlnyNazev":
+                case "ICO":
+                case "IZO":
+                case "SkolaDruhTyp":
+                case "SkolaKapacita":
+                case "ZrizNazev":
+                case "ZrizICO":
+                case "ZrizDatumNarozeni":
+                case "ZrizPravniForma":
+                case "MistoAdresa1":
+                case "MistoAdresa2":
+                case "MistoAdresa3":
+                    state = XMLState.None;
+                    break;
+            }
+        })
+            .on("text", (text) => {
+            switch (state) {
+                case XMLState.SchoolName:
+                    currentSchool.name = text;
+                    break;
+                case XMLState.Izo:
+                    currentIzo = text;
+                    break;
+                case XMLState.Ico:
+                    currentIco = text;
+                    break;
+                case XMLState.SchoolType:
+                    currentType = text;
+                    if (text === SCHOOL_TYPE_PRIMARY) {
+                        isCurrentSchoolPrimary = true;
+                    }
+                    break;
+                case XMLState.RuianCode:
+                    isRuianCodeSet = true;
+                    currentLocations.push({
+                        addressPointId: parseInt(text),
+                    });
+                    break;
+                case XMLState.Address:
+                    currentAddress.push(text);
+                    break;
+                case XMLState.FounderName:
+                    currentFounderName = text;
+                    break;
+                case XMLState.FounderIco:
+                    currentFounderIco = text;
+                    break;
+                case XMLState.FounderType:
+                    currentFounderType = text;
+                    break;
+                case XMLState.Capacity:
+                    currentCapacity = parseInt(text);
+                    break;
+            }
+        })
+            .on("error", reject)
+            .on("end", resolve);
+        // wanted to use 'await pipeline(createReadStream(getXmlFilePath(options)), saxStream)'
+        // but the program would quit spontaneously after finishing stream - using Promise instead.
+        createReadStream(getXmlFilePath(options)).pipe(saxStream);
+    });
+    yield streamPromise;
+    return { schools, founders, schoolsWithoutRuian };
+});
+const importDataToDb = (options, saveFoundersToCsv = false, saveSchoolsWithoutRuianToCsv = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const { schools, founders, schoolsWithoutRuian } = yield processSchoolRegisterXml(options);
+    if (saveFoundersToCsv) {
+        const csvFile = "founders.csv";
+        if (existsSync(csvFile)) {
+            rmSync(csvFile);
+        }
+        var csv = createWriteStream(csvFile, {
+            flags: "a",
+        });
+        csv.write("IČO;Zřizovatel;Právní forma;Počet škol;Školy\n");
+        founders.forEach((founder) => {
+            csv.write(`#${founder.ico};${founder.name};${founder.originalType};${founder.schools.length};${founder.schools.map((school) => school.name).join("---")}\n`);
+        });
+        csv.end();
+    }
+    if (saveSchoolsWithoutRuianToCsv) {
+        const csvFile = "schoolsWithoutRuian.csv";
+        if (existsSync(csvFile)) {
+            rmSync(csvFile);
+        }
+        var csv = createWriteStream(csvFile, {
+            flags: "a",
+        });
+        csv.write("IZO;Je základní;adresa1;adresa2;adresa3\n");
+        schoolsWithoutRuian.forEach((schoolAddress) => {
+            csv.write(`#${schoolAddress.izo};${schoolAddress.isPrimary ? "TRUE" : "FALSE"};${schoolAddress.address.join(";")}\n`);
+        });
+        csv.end();
+    }
+    setDbConfig({
+        filePath: options.dbFilePath,
+        initFilePath: options.dbInitFilePath,
+    });
+    insertSchools(schools);
+    insertFounders(Array.from(founders.values()));
+});
+const getXmlFilePath = (options) => {
+    return join(options.tmpDir, options.schoolsXmlFileName);
+};
+export const downloadAndImportAllSchools = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const runOptions = prepareOptions(options);
+    yield downloadXml(runOptions);
+    yield importDataToDb(runOptions, false, true);
+});
+export const deleteSchoolsXmlFile = (options = {}) => {
+    const runOptions = prepareOptions(options);
+    if (existsSync(getXmlFilePath(runOptions))) {
+        rmSync(getXmlFilePath(runOptions));
+    }
+};

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

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

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

@@ -0,0 +1,77 @@
+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 fetch from "node-fetch";
+import { createWriteStream, rmSync, existsSync, mkdirSync } from "fs";
+import { pipeline } from "stream/promises";
+import { join } from "path";
+import AdmZip from "adm-zip";
+import parseDBF from "parsedbf";
+import { prepareOptions, initDb, } from "../utils/helpers";
+import { deleteStreets, getAllSyncedStreets, insertStreetsFromDbf, setStreetAsSynced, } from "../db/street-sync";
+import { getAllUrlsFromAtomFeed, getLatestUrlFromAtomFeed, } from "../utils/atom";
+const prepareFolders = (options) => {
+    const tempFolder = getTempFolder(options);
+    if (!existsSync(tempFolder)) {
+        mkdirSync(tempFolder);
+    }
+};
+const getTempFolder = (options) => {
+    return join(options.tmpDir, options.streetFolderName);
+};
+const downloadZipAndParseDbfFile = (url, index, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(url);
+    if (response.status !== 200) {
+        throw new Error(`The ZIP file from '${url}' could not be downloaded. HTTP Code: ${response.status}`);
+    }
+    const zipFilePath = join(getTempFolder(options), `street${index}.zip`);
+    yield pipeline(response.body, createWriteStream(zipFilePath));
+    const zip = new AdmZip(zipFilePath);
+    const folderName = zip.getEntries()[0].entryName;
+    const dbfEntryName = `${folderName}${options.streetDbfFileName}`;
+    const obj = parseDBF(zip.getEntry(dbfEntryName).getData(), "win1250");
+    rmSync(zipFilePath);
+    return obj;
+});
+const importDataToDb = (data, options) => __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* () {
+    const completeOptions = prepareOptions(options);
+    initDb(completeOptions);
+    prepareFolders(completeOptions);
+    const allDatasetFeedLinks = yield getAllUrlsFromAtomFeed(completeOptions.streetsAtomUrl);
+    console.log(`Total of ${allDatasetFeedLinks.length} links to ZIP files.`);
+    const syncedStreetLinks = getAllSyncedStreets();
+    const toDelete = [];
+    // remove all deprecated links (not in the new list)
+    syncedStreetLinks.forEach((link) => {
+        if (!allDatasetFeedLinks.includes(link)) {
+            toDelete.push(link);
+            delete syncedStreetLinks[link];
+        }
+    });
+    deleteStreets(toDelete);
+    let done = syncedStreetLinks.size;
+    console.log(`Total of ${done} links to ZIP files already stored.`);
+    // get all links not yet stored
+    const newLinks = allDatasetFeedLinks.filter((link) => !syncedStreetLinks.has(link));
+    console.log(`Loading ${newLinks.length} new links to ZIP files.`);
+    for (const link of newLinks) {
+        const zipLink = yield getLatestUrlFromAtomFeed(link);
+        const dbfObject = yield downloadZipAndParseDbfFile(zipLink, done, completeOptions);
+        yield importDataToDb(dbfObject, completeOptions);
+        setStreetAsSynced(link);
+        done++;
+        console.log(`Loaded links: ${done}/${allDatasetFeedLinks.length}`);
+    }
+});

package/dist/smd-to-csv/json-to-csv.d.ts

@@ -0,0 +1 @@
+export function districtsToCsvRules(districts: any, includeDistrictName?: boolean): string;

package/dist/smd-to-csv/json-to-csv.js

@@ -0,0 +1,153 @@
+import { readFileSync } from "fs";
+const streetNamePattern = /^([^ -]+([ -]?[^ -]+)*)/;
+const streetSeriesPartPattern = /(lichá č.|sudá č.|č. p.|č.)/;
+const rangePattern = /(\d+[a-z]? ?[-] ?\d+[a-z]?|(od )?\d+[a-z]?( a)? výše|\d+[a-z]?)(, ?| a )/;
+const numberPattern = /\d+/;
+const OddTypeString = "lichá č.";
+const EvenTypeString = "sudá č.";
+const AllTypeString = "č.";
+const CPTypeString = "č. p.";
+const StreetNumberSeriesType = {
+    Odd: "odd",
+    Even: "even",
+    CP: "cp",
+    All: "all",
+};
+const _min = 0;
+const _max = 10000;
+const StreetNumberRule = {
+    MinFrom: _min,
+    MaxTo: _max,
+    EmptyRule: {
+        type: StreetNumberSeriesType.All,
+        from: _min,
+        to: _max,
+    },
+};
+const createStreetRule = (type, from = StreetNumberRule.MinFrom, to = StreetNumberRule.MaxTo) => {
+    return {
+        type: type,
+        from: from,
+        to: to,
+    };
+};
+const getStreetRules = (numberSpecification) => {
+    let rules = [];
+    let position = 0;
+    if (numberSpecification == "") {
+        return [StreetNumberRule.EmptyRule];
+    }
+    while (position < numberSpecification.length) {
+        var remainder = numberSpecification.substr(position);
+        var match = streetSeriesPartPattern.exec(remainder);
+        // if no series type is found, it's an error
+        if (match == null || match.index != 0) {
+            return null;
+        }
+        var type = getSeriesType(match[0]);
+        position += match[0].length;
+        remainder = numberSpecification.substr(position);
+        match = streetSeriesPartPattern.exec(remainder);
+        var end = numberSpecification.length;
+        if (match != null) {
+            end = position + match.index;
+        }
+        var rangePart = numberSpecification.substr(position, end - position);
+        rules = rules.concat(getRulesFromRangePart(rangePart, type));
+        position = end;
+    }
+    return rules;
+};
+const getRulesFromRangePart = (rangePart, seriesType) => {
+    let rules = [];
+    if (removeSeparatorFromEnd(rangePart) == "") {
+        rules.push(createStreetRule(seriesType));
+        return rules;
+    }
+    let position = 0;
+    rangePart = rangePart.trim() + ", ";
+    while (position < rangePart.length) {
+        var match = rangePattern.exec(rangePart.substr(position));
+        if (match == null) {
+            break;
+        }
+        position += match.index + match[0].length;
+        var value = removeSeparatorFromEnd(match[0]);
+        if (value.indexOf("-") != -1) {
+            var fromTo = value.split("-");
+            rules.push(createStreetRule(seriesType, parseInt(fromTo[0]), fromTo[1]));
+        }
+        else if (value.indexOf("výše") != -1) {
+            var number = parseInt(numberPattern.exec(value)[0]);
+            rules.push(createStreetRule(seriesType, number));
+        }
+        else {
+            var number = parseInt(numberPattern.exec(value)[0]);
+            rules.push(createStreetRule(seriesType, number, number));
+        }
+    }
+    return rules;
+};
+const getSeriesType = (pattern) => {
+    switch (pattern) {
+        case OddTypeString:
+            return StreetNumberSeriesType.Odd;
+        case EvenTypeString:
+            return StreetNumberSeriesType.Even;
+        case CPTypeString:
+            return StreetNumberSeriesType.CP;
+        case AllTypeString:
+        default:
+            return StreetNumberSeriesType.All;
+    }
+};
+const removeSeparatorFromEnd = (text) => {
+    text = text.trim();
+    if (text[text.length - 1] == "a" || text[text.length - 1] == ",") {
+        text = text.substr(0, text.length - 1);
+    }
+    return text.trim();
+};
+// desired output format:
+// Příčná(str);from(int);to(int);[odd|even|all|cp];school(str)
+export function districtsToCsvRules(districts, includeDistrictName = false) {
+    const lines = [];
+    districts.forEach((district) => {
+        district.schools.forEach((school) => {
+            school.lines.forEach((street) => {
+                if (street[0] == "!" || street == "") {
+                    return;
+                }
+                let result = streetNamePattern.exec(street);
+                let streetName = result[0];
+                let numberSpecification = street.substr(streetName.length + 3).trim();
+                let rules = getStreetRules(numberSpecification);
+                if (rules == null || rules.length == 0) {
+                    console.error("Error: " + street);
+                    return;
+                }
+                rules.forEach((rule) => {
+                    lines.push(streetName +
+                        ";" +
+                        rule.from +
+                        ";" +
+                        rule.to +
+                        ";" +
+                        rule.type +
+                        ";" +
+                        school.name +
+                        (includeDistrictName ? ";" + district.name : ""));
+                });
+            });
+        });
+    });
+    return lines.join("\n");
+}
+// let raw = readFileSync("out.json", "utf-8");
+// let districts;
+// try {
+//   districts = JSON.parse(raw);
+// } catch (error) {
+//   console.log(error);
+//   return;
+// }

package/dist/smd-to-csv/ordinance-to-csv-rules.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/smd-to-csv/ordinance-to-csv-rules.js

@@ -0,0 +1,31 @@
+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 { districtsToCsvRules } from "./json-to-csv.js";
+import { getParsedDistricts } from "./txt-to-json.js";
+import { writeFileSync } from "fs";
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    // take first node argument as a file name
+    if (process.argv.length < 3) {
+        console.error("Missing file name argument");
+        process.exit(1);
+    }
+    const fileName = process.argv[2];
+    const districts = yield getParsedDistricts(fileName);
+    const csv = districtsToCsvRules(districts);
+    if (process.argv.length >= 4) {
+        const outputFileName = process.argv[3];
+        console.log(`Writing output to ${outputFileName}`);
+        writeFileSync(outputFileName, csv);
+    }
+    else {
+        console.log(csv);
+    }
+});
+main();

package/dist/smd-to-csv/txt-to-json.d.ts

@@ -0,0 +1 @@
+export function getParsedDistricts(filePath: any): Promise<any[]>;

package/dist/smd-to-csv/txt-to-json.js

@@ -0,0 +1,102 @@
+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 { createReadStream } from "fs";
+import { once } from "events";
+import { createInterface } from "readline";
+const pattern = /^([^ –,-]+([ –-][^ ,–-]+)*)( [–-] (lichá č.|sudá č.|č.|č. p.)( (\d+[a-zA-Z]? ?[–-] ?\d+[a-zA-Z]?|(od )?\d+[a-zA-Z]?( a)? výše|\d+[a-zA-Z]?)((, ?| ?a ?)(\d+[a-zA-Z]? ?[–-] ?\d+[a-zA-Z]?|(od )?\d+[a-zA-Z]?( a)? výše|\d+[a-zA-Z]?))*)?((, ?| ?a ?)(lichá č.|sudá č.|č.|č. p.)( (\d+[a-zA-Z]? ?[–-] ?\d+[a-zA-Z]?|(od )?\d+[a-zA-Z]?( a)? výše|\d+[a-zA-Z]?)((, ?| ?a ?)(\d+[a-zA-Z]? ?[–-] ?\d+[a-zA-Z]?|(od )?\d+[a-zA-Z]?( a)? výše|\d+[a-zA-Z]?))*)?)*)?$/;
+function getNewDistrict(name) {
+    return {
+        name: name,
+        schools: [],
+    };
+}
+function getNewSchool(name) {
+    return {
+        name: name,
+        lines: [],
+    };
+}
+export function getParsedDistricts(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rl = createInterface({
+            input: createReadStream(filePath),
+        });
+        let lineNumber = 1;
+        let districts = [];
+        let currentDistrict = null;
+        let currentSchool = null;
+        rl.on("line", function (line) {
+            let s = line
+                .trim()
+                .replace(/ +(?= )/g, "")
+                .replace(/–/g, "-")
+                .replace(/nábř\./g, "nábřeží")
+                .replace(/Nábř\./g, "Nábřeží")
+                .replace(/nám\./g, "náměstí")
+                .replace(/Nám\./g, "Náměstí");
+            if (s[0] == "#") {
+                if (currentSchool != null) {
+                    if (currentDistrict == null) {
+                        currentDistrict = getNewDistrict("");
+                    }
+                    currentDistrict.schools.push(currentSchool);
+                    currentSchool = null;
+                }
+                if (currentDistrict != null) {
+                    districts.push(currentDistrict);
+                }
+                currentDistrict = getNewDistrict(s.substring(1).trim());
+                currentSchool = null;
+            }
+            else if (s == "") {
+                if (currentSchool != null) {
+                    if (currentDistrict == null) {
+                        currentDistrict = getNewDistrict("");
+                    }
+                    currentDistrict.schools.push(currentSchool);
+                    currentSchool = null;
+                }
+            }
+            else {
+                if (currentSchool == null) {
+                    currentSchool = getNewSchool(s);
+                }
+                else {
+                    if (s[0] == "!") {
+                        currentSchool.lines.push(s);
+                    }
+                    else {
+                        if (pattern.test(s)) {
+                            currentSchool.lines.push(s);
+                        }
+                        else {
+                            console.error("Invalid street line on line " + lineNumber + ": " + s);
+                        }
+                    }
+                }
+            }
+            lineNumber++;
+        });
+        rl.on("close", function () {
+            if (currentSchool != null) {
+                if (currentDistrict == null) {
+                    currentDistrict = getNewDistrict("");
+                }
+                currentDistrict.schools.push(currentSchool);
+            }
+            if (currentDistrict != null) {
+                districts.push(currentDistrict);
+            }
+            // console.log(JSON.stringify(districts));
+        });
+        yield once(rl, "close");
+        return districts;
+    });
+}