text-to-map 1.0.8 → 1.1.0

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

@@ -7,16 +7,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import fetch from "node-fetch";
-import { createWriteStream, createReadStream, rmSync, readdirSync, existsSync, } from "fs";
-import { pipeline } from "stream/promises";
-import { join } from "path";
 import AdmZip from "adm-zip";
 import { parse } from "csv-parse";
+import { createReadStream, createWriteStream, readdirSync, rmSync } from "fs";
 import iconv from "iconv-lite";
-import { prepareOptions, initDb, } from "../utils/helpers";
-import { commitAddressPoints, importParsedLine } from "../db/address-points";
+import fetch from "node-fetch";
+import { join } from "path";
+import { pipeline } from "stream/promises";
+import { commitAddressPoints } from "../db/address-points";
+import { disconnectKnex } from "../db/db";
 import { getLatestUrlFromAtomFeed } from "../utils/atom";
+import { prepareOptions, } from "../utils/helpers";
+const maxBufferSize = 1000;
 const downloadAndUnzip = (url, options) => __awaiter(void 0, void 0, void 0, function* () {
     const zipFilePath = join(options.tmpDir, options.addressPointsZipFileName);
     console.log("Downloading a large ZIP file with RUIAN data (~65 MB)...");
@@ -39,31 +41,39 @@ const importDataToDb = (options) => __awaiter(void 0, void 0, void 0, function*
     let total = 0;
     let next = 0;
     console.log("Initiating import of RUIAN data to search DB (~3 million rows to be imported).");
-    initDb(options);
+    const buffer = [];
     for (const file of files) {
-        const parseStream = parse({ delimiter: ";", fromLine: 2 }).on("data", (data) => {
-            total += importParsedLine(data);
-            if (total - next >= 100000) {
-                next += 100000;
-                console.log(`Total imported rows: ${next}`);
+        const parseStream = parse({ delimiter: ";", fromLine: 2 }).on("data", (data) => __awaiter(void 0, void 0, void 0, function* () {
+            buffer.push(data);
+            if (buffer.length >= maxBufferSize) {
+                parseStream.pause();
+                total += yield commitAddressPoints(buffer);
+                if (total - next >= 100000) {
+                    next += 100000;
+                    console.log(`Total imported rows: ${next}`);
+                }
+                buffer.length = 0;
+                parseStream.resume();
             }
-        });
+        }));
         yield pipeline(createReadStream(join(extractionFolder, file)), iconv.decodeStream("win1250"), parseStream);
-        total += commitAddressPoints();
     }
+    total += yield commitAddressPoints(buffer);
     console.log(`Import completed. Total imported rows: ${total}`);
 });
 const getExtractionFolder = (options) => join(options.tmpDir, options.addressPointsCsvFolderName);
 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 deleteDb = (options = {}) => {
-    const completeOptions = prepareOptions(options);
-    if (existsSync(completeOptions.dbFilePath)) {
-        rmSync(completeOptions.dbFilePath);
+    try {
+        const completeOptions = prepareOptions(options);
+        const datasetFeedLink = yield getLatestUrlFromAtomFeed(completeOptions.addressPointsAtomUrl);
+        const zipUrl = yield getLatestUrlFromAtomFeed(datasetFeedLink);
+        // await downloadAndUnzip(zipUrl, completeOptions);
+        yield importDataToDb(completeOptions);
     }
-};
+    catch (error) {
+        console.error(error);
+    }
+    finally {
+        yield disconnectKnex();
+    }
+});

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,3 +1,12 @@
+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 /;
@@ -7,7 +16,7 @@ const wholeMunicipalityPattern = /^území (?<type>městské části|městského
 export const isMunicipalitySwitch = (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) {
         return {
@@ -22,12 +31,12 @@ export const getSwitchMunicipality = (line) => {
         };
     }
     const { type, name } = match.groups;
-    return getMunicipalityResult(type, name, line);
-};
+    return yield getMunicipalityResult(type, name, line);
+});
 export const isWholeMunicipality = (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 {
@@ -42,11 +51,11 @@ export const getWholeMunicipality = (line) => {
         };
     }
     const { type, name } = match.groups;
-    return getMunicipalityResult(type, name, line);
-};
-const getMunicipalityResult = (type, name, line) => {
+    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 {
@@ -54,7 +63,7 @@ const getMunicipalityResult = (type, name, line) => {
         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.js

@@ -25,11 +25,14 @@ export const parseLine = (text, showDebug = false) => {
     smdParser.input = lexingResult.tokens;
     const smdLines = smdParser.street();
     if (smdParser.errors.length > 0) {
-        errors.push(...smdParser.errors.map((error) => ({
-            message: `Nesprávný zápis pravidla - nevynechali jste něco?`,
-            startOffset: error.token.startOffset,
-            endOffset: error.token.endOffset,
-        })));
+        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);
         }

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

@@ -1,11 +1,10 @@
 import { Founder } from "../db/types";
-import { OpenDataSyncOptionsPartial } from "../utils/helpers";
 import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, ProcessLineCallbackParams, School, SmdError, 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[];
+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) => {
+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, options?: OpenDataSyncOptionsPartial) => School;
+}>;
+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) {
-            return [];
+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));
+        }
+        if (state.currentMunicipality != null) {
+            state.municipalities.push(convertMunicipality(state.currentMunicipality));
         }
-        state.currentMunicipality.schools.push(mapSchoolForExport(state.currentSchool));
+        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, onError }) => {
+});
+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,18 +97,18 @@ const processMunicipalityLine = ({ line, state, onError }) => {
     if (state.currentMunicipality !== null) {
         state.municipalities.push(convertMunicipality(state.currentMunicipality));
     }
-    const { municipality, errors } = getNewMunicipality(line);
+    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, onError, }) => {
+const processSchoolLine = ({ line, lineNumber, state, onError, }) => __awaiter(void 0, void 0, void 0, function* () {
     if (state.currentMunicipality === null) {
         onError({
             lineNumber,
@@ -108,58 +119,48 @@ const processSchoolLine = ({ line, lineNumber, state, onError, }) => {
         });
         return;
     }
-    state.currentSchool = getNewSchool(line, state.currentMunicipality.founder, lineNumber, onError);
+    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 {
         municipality: {
             municipalityName: founder ? founder.name : "Neznámá obec",
@@ -168,15 +169,8 @@ export const getNewMunicipality = (name, options) => {
         },
         errors,
     };
-};
-export const getNewSchool = (name, founder, lineNumber, onError, 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,
         izo: "",
@@ -191,7 +185,7 @@ export const getNewSchool = (name, founder, lineNumber, onError, options) => {
             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;
                 }
@@ -199,7 +193,7 @@ export const getNewSchool = (name, founder, lineNumber, onError, options) => {
         }
     }
     return exportSchool;
-};
+});
 const mapAddressPointForExport = (addressPoint) => {
     return {
         address: addressPoint.address,

package/dist/utils/helpers.d.ts

@@ -19,7 +19,6 @@ export interface OpenDataSyncOptions {
 export type OpenDataSyncOptionsPartial = Partial<OpenDataSyncOptions>;
 export declare const getAppDataDirPath: () => string;
 export declare const prepareOptions: (options: OpenDataSyncOptionsPartial) => OpenDataSyncOptions;
-export declare const initDb: (options: OpenDataSyncOptions) => void;
 export declare const extractMunicipalityName: (founder: Founder) => string;
 export declare const sanitizeMunicipalityName: (name: string) => string;
 export declare const findClosestString: (str: string, arr: string[]) => string;