text-to-map 1.0.7 → 1.1.0

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

@@ -11,8 +11,9 @@ 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";
+import { prepareOptions } from "../utils/helpers";
+import { disconnectKnex } from "../db/db";
 const downloadAndImportDataToDb = (options) => __awaiter(void 0, void 0, void 0, function* () {
     console.log("Downloading regions and ORP data...");
     const response = yield fetch(options.regionsCsvUrl);
@@ -32,11 +33,18 @@ const downloadAndImportDataToDb = (options) => __awaiter(void 0, void 0, void 0,
     // @ts-ignore
     const schema = yield schemaResponse.json();
     console.log("Parsing completed. Starting to import data to DB...");
-    initDb(options);
-    insertRegionsAndOrps(rows, schema);
+    yield insertRegionsAndOrps(rows, schema);
     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);
+    try {
+        const completeOptions = prepareOptions(options);
+        yield downloadAndImportDataToDb(completeOptions);
+    }
+    catch (error) {
+        console.log(error);
+    }
+    finally {
+        yield disconnectKnex();
+    }
 });

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

@@ -8,15 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { createReadStream, createWriteStream, existsSync, rmSync } from "fs";
+import fetch from "node-fetch";
 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 { disconnectKnex } from "../db/db";
 import { insertFounders } from "../db/founders";
+import { insertSchools } from "../db/schools";
+import { MunicipalityType } from "../db/types";
+import { prepareOptions, } from "../utils/helpers";
 const downloadXml = (options) => __awaiter(void 0, void 0, void 0, function* () {
     if (existsSync(getXmlFilePath(options))) {
         return;
@@ -293,21 +293,25 @@ const importDataToDb = (options, saveFoundersToCsv = false, saveSchoolsWithoutRu
         });
         csv.end();
     }
-    setDbConfig({
-        filePath: options.dbFilePath,
-        initFilePath: options.dbInitFilePath,
-    });
-    insertSchools(schools);
-    insertFounders(Array.from(founders.values()));
+    yield insertSchools(schools);
+    yield insertFounders(Array.from(founders.values()));
 });
 const getXmlFilePath = (options) => {
     return join(options.tmpDir, options.schoolsXmlFileName);
 };
 export const downloadAndImportSchools = (options, saveFoundersToCsv = false, saveSchoolsWithoutRuianToCsv = false) => __awaiter(void 0, void 0, void 0, function* () {
-    const runOptions = prepareOptions(options);
-    yield downloadXml(runOptions);
-    yield importDataToDb(runOptions, saveFoundersToCsv, saveSchoolsWithoutRuianToCsv);
-    deleteSchoolsXmlFile(runOptions);
+    try {
+        const runOptions = prepareOptions(options);
+        yield downloadXml(runOptions);
+        yield importDataToDb(runOptions, saveFoundersToCsv, saveSchoolsWithoutRuianToCsv);
+        deleteSchoolsXmlFile(runOptions);
+    }
+    catch (error) {
+        console.error(error);
+    }
+    finally {
+        yield disconnectKnex();
+    }
 });
 export const deleteSchoolsXmlFile = (options = {}) => {
     const runOptions = prepareOptions(options);

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

@@ -7,15 +7,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 { createWriteStream, existsSync, mkdirSync, rmSync } from "fs";
+import fetch from "node-fetch";
 import parseDBF from "parsedbf";
-import { prepareOptions, initDb, } from "../utils/helpers";
+import { join } from "path";
+import { pipeline } from "stream/promises";
 import { deleteStreets, getAllSyncedStreets, insertStreetsFromDbf, setStreetAsSynced, } from "../db/street-sync";
 import { getAllUrlsFromAtomFeed, getLatestUrlFromAtomFeed, } from "../utils/atom";
+import { prepareOptions, } from "../utils/helpers";
+import { disconnectKnex } from "../db/db";
+import { areAddressPointsSynced } from "../db/address-points";
 const prepareFolders = (options) => {
     const tempFolder = getTempFolder(options);
     if (!existsSync(tempFolder)) {
@@ -43,36 +45,47 @@ const importDataToDb = (data) => __awaiter(void 0, void 0, void 0, function* ()
     if (data.length === 0) {
         return;
     }
-    insertStreetsFromDbf(data);
+    yield insertStreetsFromDbf(data);
 });
 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);
-    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];
+    try {
+        // first check if address points are already synced
+        if (!(yield areAddressPointsSynced())) {
+            throw new Error("Address points are not synced yet. First run 'npm run address-points' and then try again.");
         }
-    });
-    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);
-        setStreetAsSynced(link);
-        done++;
-        console.log(`Loaded links: ${done}/${allDatasetFeedLinks.length}`);
+        console.log("Starting to download and import streets. This takes up to 1 hour.");
+        const completeOptions = prepareOptions(options);
+        prepareFolders(completeOptions);
+        const allDatasetFeedLinks = yield getAllUrlsFromAtomFeed(completeOptions.streetsAtomUrl);
+        console.log(`Total of ${allDatasetFeedLinks.length} links to ZIP files.`);
+        const syncedStreetLinks = yield 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];
+            }
+        });
+        yield 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);
+            yield setStreetAsSynced(link);
+            done++;
+            console.log(`Loaded links: ${done}/${allDatasetFeedLinks.length}`);
+        }
+    }
+    catch (error) {
+        console.log(error);
+    }
+    finally {
+        yield disconnectKnex();
     }
 });

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

@@ -1,5 +1,5 @@
 import { DbMunicipalityResult } from "./types";
 export declare const isMunicipalitySwitch: (line: string) => boolean;
-export declare const getSwitchMunicipality: (line: string) => DbMunicipalityResult;
+export declare const getSwitchMunicipality: (line: string) => Promise<DbMunicipalityResult>;
 export declare const isWholeMunicipality: (line: string) => boolean;
-export declare const getWholeMunicipality: (line: string) => DbMunicipalityResult;
+export declare const getWholeMunicipality: (line: string) => Promise<DbMunicipalityResult>;

package/dist/street-markdown/municipality.js

@@ -1,37 +1,69 @@
+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 { findMunicipalityByNameAndType } from "../db/founders";
 import { MunicipalityType } from "../db/types";
+const municipalitySwitchStartPattern = /^navíc ulice /;
 const municipalitySwitchPattern = /^navíc ulice (z )?(?<type>městské části|městského obvodu|obce|města) (?<name>.+):$/;
+const wholeMunicipalityStartPattern = /^území /;
 const wholeMunicipalityPattern = /^území (?<type>městské části|městského obvodu|obce|města) (?<name>.+)$/;
 export const isMunicipalitySwitch = (line) => {
-    return municipalitySwitchPattern.test(line);
+    return municipalitySwitchStartPattern.test(line);
 };
-export const getSwitchMunicipality = (line) => {
+export const getSwitchMunicipality = (line) => __awaiter(void 0, void 0, void 0, function* () {
     const match = municipalitySwitchPattern.exec(line);
     if (match === null) {
-        throw new Error("Invalid municipality switch line");
+        return {
+            errors: [
+                {
+                    message: "Neplatný zápis pro dočasnou změnu obce v definici ulic. Správný zápis je: navíc ulice <typ> <název obce>. Např.: 'navíc ulice obce Mokrá Lhota:' (název obce musí být v 1. pádě).",
+                    startOffset: 0,
+                    endOffset: line.length + 1,
+                },
+            ],
+            municipality: null,
+        };
     }
     const { type, name } = match.groups;
-    return getMunicipalityResult(type, name);
-};
+    return yield getMunicipalityResult(type, name, line);
+});
 export const isWholeMunicipality = (line) => {
-    return wholeMunicipalityPattern.test(line);
+    return wholeMunicipalityStartPattern.test(line);
 };
-export const getWholeMunicipality = (line) => {
+export const getWholeMunicipality = (line) => __awaiter(void 0, void 0, void 0, function* () {
     const match = wholeMunicipalityPattern.exec(line);
     if (match === null) {
-        return { errors: ["Invalid whole municipality line"], municipality: null };
+        return {
+            errors: [
+                {
+                    message: "Neplatný zápis pro přidání celé obce. Správný zápis je: území <typ> <název obce>. Např.: 'území obce Kladno' (název obce musí být v 1. pádě).",
+                    startOffset: 0,
+                    endOffset: line.length + 1,
+                },
+            ],
+            municipality: null,
+        };
     }
     const { type, name } = match.groups;
-    return getMunicipalityResult(type, name);
-};
-const getMunicipalityResult = (type, name) => {
+    return yield getMunicipalityResult(type, name, line);
+});
+const getMunicipalityResult = (type, name, line) => __awaiter(void 0, void 0, void 0, function* () {
     const typeValue = getMunicipalityType(type);
-    const { municipality, errors } = findMunicipalityByNameAndType(name, typeValue);
+    const { municipality, errors } = yield findMunicipalityByNameAndType(name, typeValue);
+    const startOffset = line.indexOf(name);
+    const endOffset = startOffset + name.length + 1;
     return {
         municipality,
-        errors,
+        errors: errors.map((error) => (Object.assign(Object.assign({}, error), { startOffset,
+            endOffset }))),
     };
-};
+});
 const getMunicipalityType = (type) => {
     switch (type) {
         case "městské části":

package/dist/street-markdown/smd-line-parser.d.ts

@@ -1,4 +1,4 @@
 import { SmdParser } from "./smd-parser";
 import { ProcessedSmdLines } from "./types";
 export declare const smdParser: SmdParser;
-export declare const parseLine: (text: string) => ProcessedSmdLines;
+export declare const parseLine: (text: string, showDebug?: boolean) => ProcessedSmdLines;

package/dist/street-markdown/smd-line-parser.js

@@ -1,29 +1,42 @@
 import { Lexer } from "chevrotain";
 import { SmdParser } from "./smd-parser";
-// const token_definition = require("token_definition");
 import { tokenVocabulary, smdTokens, resetTokenState, prepareLine, } from "./token-definition";
 const printLexingResultInfo = (lexingResult) => {
-    // console.error(JSON.stringify(lexingResult, null, "\t"));
     const tokens = lexingResult.tokens.map((token) => "'" + token.image + "' (" + token.tokenType.name + ")");
     console.error(tokens);
 };
 const smdLexer = new Lexer(smdTokens, { positionTracking: "onlyOffset" });
 export const smdParser = new SmdParser(tokenVocabulary);
-export const parseLine = (text) => {
+export const parseLine = (text, showDebug = false) => {
     resetTokenState(); // this is needed to reset the token state between lines
     const errors = [];
     const lexingResult = smdLexer.tokenize(prepareLine(text));
     if (lexingResult.errors.length > 0) {
-        errors.push(...lexingResult.errors.map((error) => error.message));
-        printLexingResultInfo(lexingResult);
+        errors.push(...lexingResult.errors.map((error) => ({
+            message: `Neočekávaný znak na tomto místě.`,
+            startOffset: error.offset,
+            endOffset: error.offset + error.length + 1,
+        })));
+        if (showDebug) {
+            printLexingResultInfo(lexingResult);
+        }
         return { smdLines: [], errors };
     }
-    // printLexingResultInfo(lexingResult);
     smdParser.input = lexingResult.tokens;
     const smdLines = smdParser.street();
     if (smdParser.errors.length > 0) {
-        errors.push(...smdParser.errors.map((error) => error.message));
-        printLexingResultInfo(lexingResult);
+        errors.push(...smdParser.errors.map((error) => {
+            var _a;
+            return ({
+                message: `Nesprávný zápis pravidla - nevynechali jste něco?`,
+                startOffset: error.token.startOffset,
+                endOffset: (_a = error.token.endOffset) !== null && _a !== void 0 ? _a : text.length,
+            });
+        }));
+        if (showDebug) {
+            printLexingResultInfo(lexingResult);
+        }
+        return { smdLines: [], errors };
     }
     return { smdLines, errors };
 };

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

@@ -1,7 +1,10 @@
 import { Founder } from "../db/types";
-import { OpenDataSyncOptionsPartial } from "../utils/helpers";
-import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, ProcessLineCallbackParams, School, SmdState } from "./types";
-export declare const parseOrdinanceToAddressPoints: (lines: string[], options?: OpenDataSyncOptionsPartial, initialState?: Partial<SmdState>, onError?: (params: ErrorCallbackParams) => void, onWarning?: (params: ErrorCallbackParams) => void, onProcessedLine?: (params: ProcessLineCallbackParams) => void) => Municipality[];
+import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, ProcessLineCallbackParams, School, SmdError, SmdState } from "./types";
+export declare const parseOrdinanceToAddressPoints: (lines: string[], initialState?: Partial<SmdState>, onError?: (params: ErrorCallbackParams) => void, onWarning?: (params: ErrorCallbackParams) => void, onProcessedLine?: (params: ProcessLineCallbackParams) => void) => Promise<Municipality[]>;
 export declare const convertMunicipality: (municipality: MunicipalityWithFounder) => Municipality;
-export declare const getNewMunicipality: (name: string, options?: OpenDataSyncOptionsPartial) => MunicipalityWithFounder;
-export declare const getNewSchool: (name: string, founder: Founder | null, options?: OpenDataSyncOptionsPartial) => School;
+export declare const getNewMunicipality: (name: string) => Promise<{
+    municipality: MunicipalityWithFounder;
+    errors: SmdError[];
+}>;
+export declare const getNewSchool: (name: string, founder: Founder | null, lineNumber: number, onError: (params: ErrorCallbackParams) => void) => Promise<School>;
+export declare const wholeLineError: (message: string, line: string) => SmdError;

package/dist/street-markdown/smd.js

@@ -1,43 +1,54 @@
+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 { checkStreetExists, findAddressPoints, getAddressPointById, } from "../db/address-points";
-import { setDbConfig } from "../db/db";
+import { disconnectKnex } from "../db/db";
 import { findFounder } from "../db/founders";
 import { findSchool } from "../db/schools";
 import { founderToMunicipality } from "../db/types";
-import { prepareOptions } from "../utils/helpers";
 import { getSwitchMunicipality, getWholeMunicipality, isMunicipalitySwitch, isWholeMunicipality, } from "./municipality";
 import { parseLine } from "./smd-line-parser";
 import { isAddressPoint, } from "./types";
-export const parseOrdinanceToAddressPoints = (lines, options = {}, initialState = {}, onError = () => { }, onWarning = () => { }, onProcessedLine = () => { }) => {
-    const readyOptions = prepareOptions(options);
-    setDbConfig({
-        filePath: readyOptions.dbFilePath,
-        initFilePath: readyOptions.dbInitFilePath,
-    });
-    const state = Object.assign({ currentMunicipality: null, currentFilterMunicipality: null, currentSchool: null, municipalities: [] }, initialState);
-    let lineNumber = 1;
-    for (const rawLine of lines) {
-        const line = cleanLine(rawLine);
-        processOneLine({
-            line,
-            state,
-            lineNumber,
-            onError,
-            onWarning,
-        });
-        onProcessedLine({ lineNumber, line });
-        lineNumber++;
-    }
-    if (state.currentSchool != null) {
-        if (state.currentMunicipality == null) {
-            state.currentMunicipality = getNewMunicipality("");
+export const parseOrdinanceToAddressPoints = (lines, initialState = {}, onError = () => { }, onWarning = () => { }, onProcessedLine = () => { }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const state = Object.assign({ currentMunicipality: null, currentFilterMunicipality: null, currentSchool: null, municipalities: [] }, initialState);
+        let lineNumber = 1;
+        for (const rawLine of lines) {
+            const line = cleanLine(rawLine);
+            yield processOneLine({
+                line,
+                state,
+                lineNumber,
+                onError,
+                onWarning,
+            });
+            onProcessedLine({ lineNumber, line });
+            lineNumber++;
+        }
+        if (state.currentSchool != null) {
+            if (state.currentMunicipality == null) {
+                return [];
+            }
+            state.currentMunicipality.schools.push(mapSchoolForExport(state.currentSchool));
         }
-        state.currentMunicipality.schools.push(mapSchoolForExport(state.currentSchool));
+        if (state.currentMunicipality != null) {
+            state.municipalities.push(convertMunicipality(state.currentMunicipality));
+        }
+        return state.municipalities;
     }
-    if (state.currentMunicipality != null) {
-        state.municipalities.push(convertMunicipality(state.currentMunicipality));
+    catch (error) {
+        console.error(error);
     }
-    return state.municipalities;
-};
+    finally {
+        yield disconnectKnex();
+    }
+});
 const filterOutSchoolAddressPoint = (addressPoints, school) => {
     const schoolPosition = school.position;
     return schoolPosition && isAddressPoint(schoolPosition)
@@ -50,10 +61,10 @@ export const convertMunicipality = (municipality) => {
         schools: municipality.schools,
     };
 };
-const processOneLine = (params) => {
+const processOneLine = (params) => __awaiter(void 0, void 0, void 0, function* () {
     const { line, state } = params;
     if (line[0] === "#") {
-        processMunicipalityLine(params);
+        yield processMunicipalityLine(params);
         return;
     }
     if (line === "") {
@@ -65,20 +76,20 @@ const processOneLine = (params) => {
         return;
     }
     if (state.currentSchool === null) {
-        processSchoolLine(params);
+        yield processSchoolLine(params);
         return;
     }
     if (isMunicipalitySwitch(line)) {
         processMunicipalitySwitchLine(params);
     }
     else if (isWholeMunicipality(line)) {
-        processWholeMunicipalityLine(params);
+        yield processWholeMunicipalityLine(params);
     }
     else {
-        processAddressPointLine(params);
+        yield processAddressPointLine(params);
     }
-};
-const processMunicipalityLine = ({ line, state }) => {
+});
+const processMunicipalityLine = ({ line, state, onError, }) => __awaiter(void 0, void 0, void 0, function* () {
     if (state.currentSchool !== null) {
         state.currentMunicipality.schools.push(state.currentSchool);
         state.currentSchool = null;
@@ -86,97 +97,95 @@ const processMunicipalityLine = ({ line, state }) => {
     if (state.currentMunicipality !== null) {
         state.municipalities.push(convertMunicipality(state.currentMunicipality));
     }
-    state.currentMunicipality = getNewMunicipality(line.substring(1).trim());
+    const { municipality, errors } = yield getNewMunicipality(line);
+    state.currentMunicipality = municipality;
     state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
     state.currentSchool = null;
-};
+});
 const processEmptyLine = ({ state }) => {
     if (state.currentSchool !== null) {
         state.currentMunicipality.schools.push(state.currentSchool);
         state.currentSchool = null;
     }
 };
-const processSchoolLine = ({ line, lineNumber, state }) => {
+const processSchoolLine = ({ line, lineNumber, state, onError, }) => __awaiter(void 0, void 0, void 0, function* () {
     if (state.currentMunicipality === null) {
-        throw new Error("No municipality defined on line " + lineNumber);
+        onError({
+            lineNumber,
+            line,
+            errors: [
+                wholeLineError("Definici školy musí předcházet definice zřizovatele (uvozená '#', např. '# Strakonice').", line),
+            ],
+        });
+        return;
     }
-    state.currentSchool = getNewSchool(line, state.currentMunicipality.founder);
+    state.currentSchool = yield getNewSchool(line, state.currentMunicipality.founder, lineNumber, onError);
     state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
-};
-const processMunicipalitySwitchLine = ({ line, state, lineNumber, onError, }) => {
-    const { municipality, errors } = getSwitchMunicipality(line);
+});
+const processMunicipalitySwitchLine = ({ line, state, lineNumber, onError, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { municipality, errors } = yield getSwitchMunicipality(line);
     if (errors.length > 0) {
         onError({ lineNumber, line, errors });
     }
     else {
         state.currentFilterMunicipality = municipality;
     }
-};
-const processWholeMunicipalityLine = ({ line, state, lineNumber, onError, }) => {
-    const { municipality, errors } = getWholeMunicipality(line);
+});
+const processWholeMunicipalityLine = ({ line, state, lineNumber, onError, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { municipality, errors } = yield getWholeMunicipality(line);
     if (errors.length > 0) {
         onError({ lineNumber, line, errors });
     }
     else {
-        const addressPoints = findAddressPoints({ wholeMunicipality: true, street: "", numberSpec: [] }, municipality);
+        const addressPoints = yield findAddressPoints({ wholeMunicipality: true, street: "", numberSpec: [] }, municipality);
         state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
     }
-};
-const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning, }) => {
+});
+const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { smdLines, errors } = parseLine(line);
     if (errors.length > 0) {
         onError({ lineNumber, line, errors });
     }
     else {
-        smdLines.forEach((smdLine) => {
-            const { exists, errors } = checkStreetExists(smdLine.street, state.currentMunicipality.founder);
+        for (const smdLine of smdLines) {
+            const { exists, errors } = yield checkStreetExists(smdLine.street, state.currentMunicipality.founder);
             if (errors.length > 0) {
                 onWarning({ lineNumber, line, errors });
             }
             if (exists) {
-                let addressPoints = findAddressPoints(smdLine, state.currentFilterMunicipality);
+                let addressPoints = yield findAddressPoints(smdLine, state.currentFilterMunicipality);
                 state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
             }
-        });
-    }
-};
-export const getNewMunicipality = (name, options) => {
-    if (options) {
-        options = prepareOptions(options);
-        setDbConfig({
-            filePath: options.dbFilePath,
-            initFilePath: options.dbInitFilePath,
-        });
-    }
-    const { founder, errors } = findFounder(name);
-    if (errors.length > 0) {
-        errors.forEach(console.error);
+        }
     }
+});
+export const getNewMunicipality = (name) => __awaiter(void 0, void 0, void 0, function* () {
+    const { founder, errors } = yield findFounder(name);
     return {
-        municipalityName: founder ? founder.name : "Neznámá obec",
-        founder,
-        schools: [],
+        municipality: {
+            municipalityName: founder ? founder.name : "Neznámá obec",
+            founder,
+            schools: [],
+        },
+        errors,
     };
-};
-export const getNewSchool = (name, founder, options) => {
-    if (options) {
-        options = prepareOptions(options);
-        setDbConfig({
-            filePath: options.dbFilePath,
-            initFilePath: options.dbInitFilePath,
-        });
-    }
+});
+export const getNewSchool = (name, founder, lineNumber, onError) => __awaiter(void 0, void 0, void 0, function* () {
     let exportSchool = {
-        name: name,
+        name,
         izo: "",
         addresses: [],
     };
     if (founder !== null) {
-        const { school } = findSchool(name, founder.schools);
+        const { school, errors } = findSchool(name, founder.schools);
+        if (errors.length > 0) {
+            onError({ lineNumber, line: name, errors });
+        }
         if (school) {
-            school.izo = school.izo || "";
+            exportSchool.name = school.name;
+            exportSchool.izo = school.izo || "";
             if (school.locations.length > 0) {
-                const position = getAddressPointById(school.locations[0].addressPointId);
+                const position = yield getAddressPointById(school.locations[0].addressPointId);
                 if (position !== null) {
                     exportSchool.position = position;
                 }
@@ -184,7 +193,7 @@ export const getNewSchool = (name, founder, options) => {
         }
     }
     return exportSchool;
-};
+});
 const mapAddressPointForExport = (addressPoint) => {
     return {
         address: addressPoint.address,
@@ -196,8 +205,13 @@ const mapSchoolForExport = (school) => ({
     name: school.name,
     izo: school.izo,
     addresses: school.addresses,
-    position: mapAddressPointForExport(school.position),
+    position: school.position ? mapAddressPointForExport(school.position) : null,
 });
 const cleanLine = (line) => {
     return line.trim().replace(/–/g, "-");
 };
+export const wholeLineError = (message, line) => ({
+    message,
+    startOffset: 0,
+    endOffset: line.length + 1,
+});