text-to-map 1.0.6 → 1.0.8

package/dist/bin/address-points.js

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

package/dist/bin/clear-all.js

@@ -1,5 +1,6 @@
 import { deleteDb } from "../open-data-sync/address-points";
 import { deleteSchoolsXmlFile } from "../open-data-sync/schools";
-deleteDb();
-deleteSchoolsXmlFile();
+import { defaultBinOptions } from "./constants";
+deleteDb(defaultBinOptions);
+deleteSchoolsXmlFile(defaultBinOptions);
 console.log("Everything cleared, ready for a new sync.");

package/dist/bin/constants.d.ts

@@ -0,0 +1,2 @@
+import { OpenDataSyncOptionsPartial } from "../utils/helpers";
+export declare const defaultBinOptions: OpenDataSyncOptionsPartial;

package/dist/bin/constants.js

@@ -0,0 +1,3 @@
+export const defaultBinOptions = {
+    dataDir: "./tmp/db",
+};

package/dist/bin/parse-ordinance.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync } from "fs";
-import { parseOrdinanceToAddressPoints } from "../street-markdown/smd";
+import { getNewMunicipality, parseOrdinanceToAddressPoints, } from "../street-markdown/smd";
+import { defaultBinOptions } from "./constants";
 // take first node argument as a file name
 if (process.argv.length < 3) {
     console.error("Missing file name argument");
@@ -8,7 +9,32 @@ if (process.argv.length < 3) {
 const fileName = process.argv[2];
 const fileContent = readFileSync(fileName);
 const lines = fileContent.toString().split("\n");
-const addressPoints = parseOrdinanceToAddressPoints(lines);
+let errorCount = 0;
+const errorLines = [];
+let warningCount = 0;
+const reportErrors = ({ lineNumber, line, errors, }) => {
+    errors.forEach((error) => console.error(error));
+    console.error(`Invalid street definition on line ${lineNumber}: ${line}`);
+    errorCount++;
+    errorLines.push(`line ${lineNumber}: ${line}`);
+};
+const reportWarnings = ({ lineNumber, errors: warnings, }) => {
+    warnings.forEach((error) => {
+        console.error(`Line ${lineNumber}: ${error.message}`);
+    });
+    warningCount++;
+};
+console.time("downloadAndImportAllLatestAddressPoints");
+const { municipality } = getNewMunicipality("Česká Lípa", defaultBinOptions);
+const addressPoints = parseOrdinanceToAddressPoints(lines, defaultBinOptions, {
+// currentMunicipality: municipality,
+}, reportErrors, reportWarnings);
+console.timeEnd("downloadAndImportAllLatestAddressPoints");
+console.log(`Parsed ${lines.length} lines, ${errorCount} errors, ${warningCount} warnings.`);
+if (errorCount > 0) {
+    console.log("Errors:");
+    errorLines.forEach((line) => console.log(line));
+}
 if (process.argv.length >= 4) {
     const outputFileName = process.argv[3];
     const output = JSON.stringify(addressPoints);

package/dist/bin/regions.js

@@ -1,5 +1,6 @@
 import { downloadAndImportRegions } from "../open-data-sync/regions";
-downloadAndImportRegions({ dataDir: "./tmp/db" })
+import { defaultBinOptions } from "./constants";
+downloadAndImportRegions(defaultBinOptions)
     .then(() => {
     console.log("Completed");
 })

package/dist/bin/schools.js

@@ -1,5 +1,6 @@
 import { downloadAndImportSchools } from "../open-data-sync/schools";
-downloadAndImportSchools({ dataDir: "./tmp/db" })
+import { defaultBinOptions } from "./constants";
+downloadAndImportSchools(defaultBinOptions, true)
     .then(() => {
     console.log("Completed");
 })

package/dist/bin/streets.js

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

package/dist/bin/sync-all.js

@@ -1,2 +1,3 @@
 import { downloadAndImportEverything } from "../index";
-downloadAndImportEverything({ dataDir: "./tmp/db" });
+import { defaultBinOptions } from "./constants";
+downloadAndImportEverything(defaultBinOptions);

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

@@ -1,4 +1,4 @@
-import { AddressPoint, FullStreetNumber, RangeSpec, SeriesType, SmdLine, WholeMunicipalitySmdLine } from "../street-markdown/types";
+import { AddressPoint, FullStreetNumber, RangeSpec, SeriesType, SmdError, SmdLine, WholeMunicipalitySmdLine } from "../street-markdown/types";
 import { Founder, Municipality } from "./types";
 export declare const Column: {
     admCode: number;
@@ -31,7 +31,7 @@ export declare const insertStreets: (buffer: string[][]) => number;
 export declare const getAddressPointById: (addressPointId: number) => AddressPoint | null;
 export declare const checkStreetExists: (streetName: string, founder: Founder) => {
     exists: boolean;
-    errors: string[];
+    errors: SmdError[];
 };
 export declare const findAddressPoints: (smdLine: SmdLine | WholeMunicipalitySmdLine, municipality: Municipality) => AddressPoint[];
 export declare const isInRange: (number: number | null, letter: string | null, range: RangeSpec) => boolean;

package/dist/db/address-points.js

@@ -153,7 +153,11 @@ export const checkStreetExists = (streetName, founder) => {
     }
     else {
         const closest = findClosestString(streetName, allStreets);
-        errors.push(`Street '${streetName}' does not exist, did you mean '${closest}'?`);
+        errors.push({
+            message: `Ulice '${streetName}' v této obci neexistuje, mysleli jste '${closest}'?`,
+            startOffset: 0,
+            endOffset: streetName.length + 1,
+        });
     }
     return { exists: false, errors };
 };

package/dist/db/db.js

@@ -23,6 +23,8 @@ export const getDb = (config = {}) => {
         const dbSettings = options.verbose ? { verbose: console.log } : {};
         _db = new Database(options.filePath, dbSettings);
         _db.pragma("journal_mode = WAL");
+        // @ts-ignore
+        _db.filePath = options.filePath;
     }
     return _db;
 };

package/dist/db/founders.d.ts

@@ -1,9 +1,9 @@
 import { Founder, MunicipalityType } from "./types";
-import { DbMunicipalityResult } from "../street-markdown/types";
+import { DbMunicipalityResult, SmdError } from "../street-markdown/types";
 export declare const insertFounders: (founders: Founder[]) => number;
-export declare const findFounder: (name: string) => {
+export declare const findFounder: (nameWithHashtag: string) => {
     founder: Founder;
-    errors: string[];
+    errors: SmdError[];
 };
 export declare const getFounderCityCode: (founder: Founder) => number;
 export declare const findMunicipalityByNameAndType: (name: string, type: MunicipalityType) => DbMunicipalityResult;

package/dist/db/founders.js

@@ -2,6 +2,7 @@ import { MunicipalityType, } from "./types";
 import { generatePlaceholders, getDb, insertAutoincrementRow, insertMultipleRows, } from "./db";
 import { extractMunicipalityName, findClosestString, sanitizeMunicipalityName, } from "../utils/helpers";
 import distance from "@turf/distance";
+import { wholeLineError } from "../street-markdown/smd";
 const cityTypeCode = 261;
 const cityDistrictTypeCode = 263;
 export const insertFounders = (founders) => {
@@ -61,11 +62,12 @@ export const insertFounders = (founders) => {
         }
         const founderId = insertAutoincrementRow([
             sanitizeMunicipalityName(founder.name),
+            sanitizeMunicipalityName(extractedMunicipalityName),
             founder.ico,
             String(founder.originalType),
             cityCode,
             cityDistrictCode,
-        ], "founder", ["name", "ico", "founder_type_code", "city_code", "city_district_code"]);
+        ], "founder", ["name", "short_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) {
@@ -177,9 +179,18 @@ const findMunicipalitiesAndPositionsByNameAndType = (name, type) => {
         lng: row.wgs84_longitude,
     }));
 };
-export const findFounder = (name) => {
+const extractFounderName = (line) => {
+    if (line[0] === "#") {
+        return line.substring(1).trim();
+    }
+    else {
+        return line.trim();
+    }
+};
+export const findFounder = (nameWithHashtag) => {
     const errors = [];
     const db = getDb();
+    const name = extractFounderName(nameWithHashtag);
     const exactMatchStatement = db.prepare(`SELECT f.id, f.name, f.ico, f.founder_type_code, f.city_code, f.city_district_code FROM founder f
     LEFT JOIN city c ON c.code = f.city_code
     LEFT JOIN city_district d ON d.code = f.city_district_code
@@ -196,7 +207,14 @@ export const findFounder = (name) => {
         const bestMatch = findClosestString(name, namesList);
         const bestMatchRow = allFounderNames.find((foundersNames) => foundersNames.founderName === bestMatch ||
             foundersNames.municipalityName === bestMatch);
-        errors.push(`No exact match for founder "${name}", using "${bestMatch}" instead.`);
+        if (!bestMatchRow) {
+            errors.push(wholeLineError(`Nenašli jsme žádné zřizovatele, nejspíš jste zapomněli inicializovat databázi.`, nameWithHashtag));
+            return {
+                founder: null,
+                errors,
+            };
+        }
+        errors.push(wholeLineError(`Zřizovatel '${name}' neexistuje, mysleli jste '${bestMatch}'?`, nameWithHashtag));
         const findByIdStatement = db.prepare(`SELECT f.id, f.name, f.ico, f.founder_type_code, f.city_code, f.city_district_code FROM founder f
       WHERE f.id = ?`);
         return {
@@ -281,7 +299,11 @@ export const findMunicipalityByNameAndType = (name, type) => {
         const namesList = allNames.map((row) => row.name);
         const bestMatch = findClosestString(name, namesList);
         const bestMatchRow = allNames.find((municipality) => municipality.name === bestMatch);
-        errors.push(`No exact match for municipality "${name}", using "${bestMatch}" instead.`);
+        errors.push({
+            message: `Obec ani městská část '${name}' neexistuje, mysleli jste '${bestMatch}'?`,
+            startOffset: 0,
+            endOffset: 0,
+        });
         return {
             municipality: { code: bestMatchRow.code, type },
             errors,

package/dist/db/schools.d.ts

@@ -1,6 +1,7 @@
+import { SmdError } from "../street-markdown/types";
 import { School } from "./types";
 export declare const insertSchools: (schools: School[]) => number;
 export declare const findSchool: (name: string, schools: School[]) => {
     school: School | null;
-    errors: string[];
+    errors: SmdError[];
 };

package/dist/db/schools.js

@@ -1,3 +1,4 @@
+import { wholeLineError } from "../street-markdown/smd";
 import { findClosestString } from "../utils/helpers";
 import { getDb, insertMultipleRows } from "./db";
 export const insertSchools = (schools) => {
@@ -35,7 +36,10 @@ export const insertSchools = (schools) => {
 };
 export const findSchool = (name, schools) => {
     if (schools.length === 0) {
-        return { school: null, errors: ["No schools for this founder."] };
+        return {
+            school: null,
+            errors: [wholeLineError("Aktuální zřizovatel nemá žádné školy.", name)],
+        };
     }
     let school = null;
     const errors = [];
@@ -46,7 +50,7 @@ export const findSchool = (name, schools) => {
     const namesList = schools.map((school) => school.name);
     const bestMatch = findClosestString(name, namesList);
     school = schools.find((school) => bestMatch === school.name);
-    errors.push(`No exact match for school "${name}", using "${bestMatch}" instead.`);
+    errors.push(wholeLineError(`Škola s názvem '${name}' neexistuje, mysleli jste '${bestMatch}'?`, name));
     return { school, errors };
 };
 const filterOutDuplicates = (schools) => {

package/dist/index.d.ts

@@ -2,9 +2,9 @@ import { downloadAndImportAddressPoints, deleteDb } from "./open-data-sync/addre
 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";
+import { OpenDataSyncOptionsPartial } from "./utils/helpers";
 export * from "./street-markdown/types";
+export * from "./street-markdown/smd";
 /**
  * Download and import all open data to SQLite DB. The DB file will be located
  * in the `dataDir` folder.
@@ -16,5 +16,5 @@ export * from "./street-markdown/types";
  * await downloadAndImportEverything({ tmpDir: "./tmp", dataDir: "./data" });
  * ```
  */
-export declare function downloadAndImportEverything(options?: OpenDataSyncOptions, syncStreets?: boolean): Promise<void>;
-export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, parseOrdinanceToAddressPoints, };
+export declare function downloadAndImportEverything(options?: OpenDataSyncOptionsPartial, syncStreets?: boolean): Promise<void>;
+export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, };

package/dist/index.js

@@ -11,8 +11,8 @@ import { downloadAndImportAddressPoints, deleteDb, } from "./open-data-sync/addr
 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";
+export * from "./street-markdown/smd";
 /**
  * Download and import all open data to SQLite DB. The DB file will be located
  * in the `dataDir` folder.
@@ -34,4 +34,4 @@ export function downloadAndImportEverything(options = {}, syncStreets = true) {
         }
     });
 }
-export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, parseOrdinanceToAddressPoints, };
+export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, };

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

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

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

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

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

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

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

@@ -303,10 +303,10 @@ const importDataToDb = (options, saveFoundersToCsv = false, saveSchoolsWithoutRu
 const getXmlFilePath = (options) => {
     return join(options.tmpDir, options.schoolsXmlFileName);
 };
-export const downloadAndImportSchools = (options) => __awaiter(void 0, void 0, void 0, function* () {
+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, false, true);
+    yield importDataToDb(runOptions, saveFoundersToCsv, saveSchoolsWithoutRuianToCsv);
     deleteSchoolsXmlFile(runOptions);
 });
 export const deleteSchoolsXmlFile = (options = {}) => {

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

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

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

@@ -23,7 +23,7 @@ const prepareFolders = (options) => {
     }
 };
 const getTempFolder = (options) => {
-    return join(options.tmpDir, options.streetFolderName);
+    return join(options.tmpDir, options.streetZipFolderName);
 };
 const downloadZipAndParseDbfFile = (url, index, options) => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield fetch(url);

package/dist/street-markdown/municipality.js

@@ -1,35 +1,58 @@
 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) => {
     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 getMunicipalityResult(type, name, line);
 };
 export const isWholeMunicipality = (line) => {
-    return wholeMunicipalityPattern.test(line);
+    return wholeMunicipalityStartPattern.test(line);
 };
 export const getWholeMunicipality = (line) => {
     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);
+    return getMunicipalityResult(type, name, line);
 };
-const getMunicipalityResult = (type, name) => {
+const getMunicipalityResult = (type, name, line) => {
     const typeValue = getMunicipalityType(type);
     const { municipality, errors } = 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) => {

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,39 @@
 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) => ({
+            message: `Nesprávný zápis pravidla - nevynechali jste něco?`,
+            startOffset: error.token.startOffset,
+            endOffset: error.token.endOffset,
+        })));
+        if (showDebug) {
+            printLexingResultInfo(lexingResult);
+        }
+        return { smdLines: [], errors };
     }
     return { smdLines, errors };
 };

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

@@ -1,9 +1,11 @@
 import { Founder } from "../db/types";
-import { OpenDataSyncOptions } from "../utils/helpers";
-import { Municipality } from "./types";
-interface MunicipalityWithFounder extends Municipality {
-    founder: Founder | null;
-}
-export declare const parseOrdinanceToAddressPoints: (lines: string[], options?: OpenDataSyncOptions) => Municipality[];
+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 convertMunicipality: (municipality: MunicipalityWithFounder) => Municipality;
-export {};
+export declare const getNewMunicipality: (name: string, options?: OpenDataSyncOptionsPartial) => {
+    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 wholeLineError: (message: string, line: string) => SmdError;

package/dist/street-markdown/smd.js

@@ -2,32 +2,194 @@ import { checkStreetExists, findAddressPoints, getAddressPointById, } from "../d
 import { setDbConfig } from "../db/db";
 import { findFounder } from "../db/founders";
 import { findSchool } from "../db/schools";
-import { founderToMunicipality, } from "../db/types";
+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";
-const getNewMunicipality = (name) => {
+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 [];
+        }
+        state.currentMunicipality.schools.push(mapSchoolForExport(state.currentSchool));
+    }
+    if (state.currentMunicipality != null) {
+        state.municipalities.push(convertMunicipality(state.currentMunicipality));
+    }
+    return state.municipalities;
+};
+const filterOutSchoolAddressPoint = (addressPoints, school) => {
+    const schoolPosition = school.position;
+    return schoolPosition && isAddressPoint(schoolPosition)
+        ? (addressPoints = addressPoints.filter((ap) => ap.id !== schoolPosition.id))
+        : addressPoints;
+};
+export const convertMunicipality = (municipality) => {
+    return {
+        municipalityName: municipality.municipalityName,
+        schools: municipality.schools,
+    };
+};
+const processOneLine = (params) => {
+    const { line, state } = params;
+    if (line[0] === "#") {
+        processMunicipalityLine(params);
+        return;
+    }
+    if (line === "") {
+        // end of school
+        processEmptyLine(params);
+        return;
+    }
+    if (line[0] === "!") {
+        return;
+    }
+    if (state.currentSchool === null) {
+        processSchoolLine(params);
+        return;
+    }
+    if (isMunicipalitySwitch(line)) {
+        processMunicipalitySwitchLine(params);
+    }
+    else if (isWholeMunicipality(line)) {
+        processWholeMunicipalityLine(params);
+    }
+    else {
+        processAddressPointLine(params);
+    }
+};
+const processMunicipalityLine = ({ line, state, onError }) => {
+    if (state.currentSchool !== null) {
+        state.currentMunicipality.schools.push(state.currentSchool);
+        state.currentSchool = null;
+    }
+    if (state.currentMunicipality !== null) {
+        state.municipalities.push(convertMunicipality(state.currentMunicipality));
+    }
+    const { municipality, errors } = 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, }) => {
+    if (state.currentMunicipality === null) {
+        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, lineNumber, onError);
+    state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
+};
+const processMunicipalitySwitchLine = ({ line, state, lineNumber, onError, }) => {
+    const { municipality, errors } = 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);
+    if (errors.length > 0) {
+        onError({ lineNumber, line, errors });
+    }
+    else {
+        const addressPoints = findAddressPoints({ wholeMunicipality: true, street: "", numberSpec: [] }, municipality);
+        state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+    }
+};
+const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning, }) => {
+    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);
+            if (errors.length > 0) {
+                onWarning({ lineNumber, line, errors });
+            }
+            if (exists) {
+                let addressPoints = 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);
     }
     return {
-        municipalityName: founder ? founder.name : "Neznámá obec",
-        founder,
-        schools: [],
+        municipality: {
+            municipalityName: founder ? founder.name : "Neznámá obec",
+            founder,
+            schools: [],
+        },
+        errors,
     };
 };
-const getNewSchool = (name, founder) => {
+export const getNewSchool = (name, founder, lineNumber, onError, options) => {
+    if (options) {
+        options = prepareOptions(options);
+        setDbConfig({
+            filePath: options.dbFilePath,
+            initFilePath: options.dbInitFilePath,
+        });
+    }
     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);
                 if (position !== null) {
@@ -49,134 +211,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 parseOrdinanceToAddressPoints = (lines, options = {}) => {
-    const readyOptions = prepareOptions(options);
-    setDbConfig({
-        filePath: readyOptions.dbFilePath,
-        initFilePath: readyOptions.dbInitFilePath,
-    });
-    let errorCount = 0;
-    const errorLines = [];
-    let warningCount = 0;
-    let lineNumber = 1;
-    let municipalities = [];
-    let currentMunicipality = null;
-    let currentFilterMunicipality = null;
-    let currentSchool = null;
-    const reportErrors = (line, errors) => {
-        errors.forEach(console.error);
-        console.error(`Invalid street definition on line ${lineNumber}: ${line}`);
-        errorCount++;
-        errorLines.push(`line ${lineNumber}: ${line}`);
-    };
-    lines.forEach((rawLine) => {
-        let line = cleanLine(rawLine);
-        if (line[0] === "#") {
-            // a new municipality
-            if (currentSchool !== null) {
-                currentMunicipality.schools.push(currentSchool);
-                currentSchool = null;
-            }
-            if (currentMunicipality !== null) {
-                municipalities.push(convertMunicipality(currentMunicipality));
-            }
-            currentMunicipality = getNewMunicipality(line.substring(1).trim());
-            currentFilterMunicipality = founderToMunicipality(currentMunicipality.founder);
-            currentSchool = null;
-        }
-        else if (line === "") {
-            // empty line (end of school)
-            if (currentSchool !== null) {
-                currentMunicipality.schools.push(currentSchool);
-                currentSchool = null;
-            }
-        }
-        else {
-            if (currentSchool === null) {
-                if (currentMunicipality === null) {
-                    throw new Error("No municipality defined on line " + lineNumber);
-                }
-                currentSchool = getNewSchool(line, currentMunicipality.founder);
-                currentFilterMunicipality = founderToMunicipality(currentMunicipality.founder);
-            }
-            else {
-                if (line[0] !== "!") {
-                    if (isMunicipalitySwitch(line)) {
-                        const { municipality, errors } = getSwitchMunicipality(line);
-                        if (errors.length > 0) {
-                            reportErrors(line, errors);
-                        }
-                        else {
-                            currentFilterMunicipality = municipality;
-                        }
-                    }
-                    else if (isWholeMunicipality(line)) {
-                        const { municipality, errors } = getWholeMunicipality(line);
-                        if (errors.length > 0) {
-                            reportErrors(line, errors);
-                        }
-                        else {
-                            const addressPoints = findAddressPoints({ wholeMunicipality: true, street: "", numberSpec: [] }, municipality);
-                            currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, currentSchool).map(mapAddressPointForExport));
-                        }
-                    }
-                    else {
-                        // address point
-                        const { smdLines, errors } = parseLine(line);
-                        if (errors.length > 0) {
-                            reportErrors(line, errors);
-                        }
-                        else {
-                            smdLines.forEach((smdLine) => {
-                                const { exists, errors } = checkStreetExists(smdLine.street, currentMunicipality.founder);
-                                if (errors.length > 0) {
-                                    errors.map((error) => {
-                                        console.error(`Line ${lineNumber}: ${error}`);
-                                    });
-                                    warningCount++;
-                                }
-                                if (exists) {
-                                    let addressPoints = findAddressPoints(smdLine, currentFilterMunicipality);
-                                    currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, currentSchool).map(mapAddressPointForExport));
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        lineNumber++;
-    });
-    if (currentSchool != null) {
-        if (currentMunicipality == null) {
-            currentMunicipality = getNewMunicipality("");
-        }
-        currentMunicipality.schools.push(mapSchoolForExport(currentSchool));
-    }
-    if (currentMunicipality != null) {
-        municipalities.push(convertMunicipality(currentMunicipality));
-    }
-    console.log(`Parsed ${lineNumber} lines, ${errorCount} errors, ${warningCount} warnings.`);
-    if (errorCount > 0) {
-        console.log("Errors:");
-        errorLines.forEach((line) => console.log(line));
-    }
-    return municipalities;
-};
-const filterOutSchoolAddressPoint = (addressPoints, school) => {
-    const schoolPosition = school.position;
-    return schoolPosition && isAddressPoint(schoolPosition)
-        ? (addressPoints = addressPoints.filter((ap) => ap.id !== schoolPosition.id))
-        : addressPoints;
-};
-export const convertMunicipality = (municipality) => {
-    return {
-        municipalityName: municipality.municipalityName,
-        schools: municipality.schools,
-    };
-};
+export const wholeLineError = (message, line) => ({
+    message,
+    startOffset: 0,
+    endOffset: line.length + 1,
+});

package/dist/street-markdown/token-definition.js

@@ -109,11 +109,11 @@ const Space = createToken({
     longer_alt: [MainSeparator, Separator],
     group: Lexer.SKIPPED,
 });
-const Colon = createToken({
-    name: "Colon",
-    pattern: /:/,
-    group: Lexer.SKIPPED,
-});
+// const Colon = createToken({
+//   name: "Colon",
+//   pattern: /:/,
+//   group: Lexer.SKIPPED,
+// });
 const smdTokens = [
     MainSeparator,
     Separator,
@@ -130,7 +130,7 @@ const smdTokens = [
     Hyphen,
     Slash,
     Space,
-    Colon,
+    // Colon,
     StreetName,
 ];
 MainSeparator.LABEL = "' - '";

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

@@ -1,8 +1,8 @@
-import { Municipality as DbMunicipality } from "../db/types";
 import { AddressPoint as CzechAddressPoint } from "czech-address";
+import { Municipality as DbMunicipality, Founder } from "../db/types";
 export interface ProcessedSmdLines {
     smdLines: SmdLine[];
-    errors: string[];
+    errors: SmdError[];
 }
 export interface SmdLine {
     street: string;
@@ -67,5 +67,33 @@ export interface Municipality {
 }
 export interface DbMunicipalityResult {
     municipality: DbMunicipality;
-    errors: string[];
+    errors: SmdError[];
+}
+export interface MunicipalityWithFounder extends Municipality {
+    founder: Founder | null;
+}
+export interface SmdState {
+    currentMunicipality: MunicipalityWithFounder;
+    currentFilterMunicipality: DbMunicipality;
+    currentSchool: School;
+    municipalities: Municipality[];
+}
+export interface ProcessLineCallbackParams {
+    lineNumber: number;
+    line: string;
+}
+export interface ErrorCallbackParams extends ProcessLineCallbackParams {
+    errors: SmdError[];
+}
+export interface ProcessLineParams {
+    line: string;
+    state: SmdState;
+    lineNumber: number;
+    onError: (params: ErrorCallbackParams) => void;
+    onWarning: (params: ErrorCallbackParams) => void;
+}
+export interface SmdError {
+    startOffset: number;
+    endOffset: number;
+    message: string;
 }

package/dist/utils/helpers.d.ts

@@ -1,22 +1,5 @@
 import { Founder } from "../db/types";
 export interface OpenDataSyncOptions {
-    tmpDir?: string;
-    dataDir?: string;
-    dbFilePath?: string;
-    dbInitFilePath?: string;
-    addressPointsAtomUrl?: string;
-    addressPointsZipFileName?: string;
-    addressPointsCsvFolderName?: string;
-    streetsAtomUrl?: string;
-    streetZipFolderName?: string;
-    streetDbfFileName?: string;
-    schoolsXmlUrl?: string;
-    schoolsXmlFileName?: string;
-    regionsCsvUrl?: string;
-    regionsSchemaUrl?: string;
-    regionsCsvFileName?: string;
-}
-export interface OpenDataSyncOptionsNotEmpty {
     tmpDir: string;
     dataDir: string;
     dbFilePath: string;
@@ -25,7 +8,7 @@ export interface OpenDataSyncOptionsNotEmpty {
     addressPointsZipFileName: string;
     addressPointsCsvFolderName: string;
     streetsAtomUrl: string;
-    streetFolderName: string;
+    streetZipFolderName: string;
     streetDbfFileName: string;
     schoolsXmlUrl: string;
     schoolsXmlFileName: string;
@@ -33,9 +16,10 @@ export interface OpenDataSyncOptionsNotEmpty {
     regionsSchemaUrl: string;
     regionsCsvFileName: string;
 }
+export type OpenDataSyncOptionsPartial = Partial<OpenDataSyncOptions>;
 export declare const getAppDataDirPath: () => string;
-export declare const prepareOptions: (options: OpenDataSyncOptions) => OpenDataSyncOptionsNotEmpty;
-export declare const initDb: (options: OpenDataSyncOptionsNotEmpty) => void;
+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;

package/dist/utils/helpers.js

@@ -10,7 +10,7 @@ export const getAppDataDirPath = () => join(process.env.APPDATA ||
         ? 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, _o, _p, _q;
+    var _a;
     const dataDir = (_a = options.dataDir) !== null && _a !== void 0 ? _a : getAppDataDirPath();
     if (!existsSync(dataDir)) {
         mkdirSync(dataDir);
@@ -21,23 +21,24 @@ export const prepareOptions = (options) => {
     }
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
-    return {
-        tmpDir: (_b = options.tmpDir) !== null && _b !== void 0 ? _b : tmpAppDir,
+    const defaults = {
+        tmpDir: 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(__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",
-        streetsAtomUrl: (_h = options.streetsAtomUrl) !== null && _h !== void 0 ? _h : "https://atom.cuzk.cz/RUIAN-OBCE-SHP/RUIAN-OBCE-SHP.xml",
-        streetFolderName: (_j = options.streetZipFolderName) !== null && _j !== void 0 ? _j : "streets",
-        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",
-        regionsSchemaUrl: (_p = options.regionsSchemaUrl) !== null && _p !== void 0 ? _p : "https://www.czso.cz/documents/10180/23208674/struktura_uzemi_cr-metadata.json",
-        regionsCsvFileName: (_q = options.regionsCsvFileName) !== null && _q !== void 0 ? _q : "struktura_uzemi_cr.csv",
+        dbFilePath: join(dataDir, "address_points.db"),
+        dbInitFilePath: join(__dirname, "..", "address_points_init.db"),
+        addressPointsAtomUrl: "https://atom.cuzk.cz/RUIAN-CSV-ADR-ST/RUIAN-CSV-ADR-ST.xml",
+        addressPointsZipFileName: "ruian_csv.zip",
+        addressPointsCsvFolderName: "CSV",
+        streetsAtomUrl: "https://atom.cuzk.cz/RUIAN-OBCE-SHP/RUIAN-OBCE-SHP.xml",
+        streetZipFolderName: "streets",
+        streetDbfFileName: "UL_L.dbf",
+        schoolsXmlUrl: "https://rejstriky.msmt.cz/opendata/vrejcelk.xml",
+        schoolsXmlFileName: "school-register.xml",
+        regionsCsvUrl: "https://www.czso.cz/documents/10180/23208674/struktura_uzemi_cr.csv",
+        regionsSchemaUrl: "https://www.czso.cz/documents/10180/23208674/struktura_uzemi_cr-metadata.json",
+        regionsCsvFileName: "struktura_uzemi_cr.csv",
     };
+    return Object.assign(Object.assign({}, defaults), options);
 };
 export const initDb = (options) => {
     setDbConfig({

package/package.json

@@ -48,7 +48,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.6",
+  "version": "1.0.8",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [