text-to-map 1.0.7 → 1.0.8

package/dist/bin/parse-ordinance.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync } from "fs";
-import { getNewMunicipality, 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) {
@@ -13,20 +13,21 @@ let errorCount = 0;
 const errorLines = [];
 let warningCount = 0;
 const reportErrors = ({ lineNumber, line, errors, }) => {
-    errors.forEach(console.error);
+    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.map((error) => {
-        console.error(`Line ${lineNumber}: ${error}`);
+    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: getNewMunicipality("Česká Lípa", defaultBinOptions),
+// currentMunicipality: municipality,
 }, reportErrors, reportWarnings);
 console.timeEnd("downloadAndImportAllLatestAddressPoints");
 console.log(`Parsed ${lines.length} lines, ${errorCount} errors, ${warningCount} warnings.`);

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) => {
@@ -178,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
@@ -197,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 {
@@ -282,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/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,7 +1,11 @@
 import { Founder } from "../db/types";
 import { OpenDataSyncOptionsPartial } from "../utils/helpers";
-import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, ProcessLineCallbackParams, School, SmdState } from "./types";
+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 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, 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

@@ -29,7 +29,7 @@ export const parseOrdinanceToAddressPoints = (lines, options = {}, initialState
     }
     if (state.currentSchool != null) {
         if (state.currentMunicipality == null) {
-            state.currentMunicipality = getNewMunicipality("");
+            return [];
         }
         state.currentMunicipality.schools.push(mapSchoolForExport(state.currentSchool));
     }
@@ -78,7 +78,7 @@ const processOneLine = (params) => {
         processAddressPointLine(params);
     }
 };
-const processMunicipalityLine = ({ line, state }) => {
+const processMunicipalityLine = ({ line, state, onError }) => {
     if (state.currentSchool !== null) {
         state.currentMunicipality.schools.push(state.currentSchool);
         state.currentSchool = null;
@@ -86,7 +86,8 @@ const processMunicipalityLine = ({ line, state }) => {
     if (state.currentMunicipality !== null) {
         state.municipalities.push(convertMunicipality(state.currentMunicipality));
     }
-    state.currentMunicipality = getNewMunicipality(line.substring(1).trim());
+    const { municipality, errors } = getNewMunicipality(line);
+    state.currentMunicipality = municipality;
     state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
     state.currentSchool = null;
 };
@@ -96,11 +97,18 @@ const processEmptyLine = ({ state }) => {
         state.currentSchool = null;
     }
 };
-const processSchoolLine = ({ line, lineNumber, state }) => {
+const processSchoolLine = ({ line, lineNumber, state, onError, }) => {
     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 = getNewSchool(line, state.currentMunicipality.founder, lineNumber, onError);
     state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
 };
 const processMunicipalitySwitchLine = ({ line, state, lineNumber, onError, }) => {
@@ -153,12 +161,15 @@ export const getNewMunicipality = (name, options) => {
         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,
     };
 };
-export const getNewSchool = (name, founder, options) => {
+export const getNewSchool = (name, founder, lineNumber, onError, options) => {
     if (options) {
         options = prepareOptions(options);
         setDbConfig({
@@ -167,14 +178,18 @@ export const getNewSchool = (name, founder, options) => {
         });
     }
     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) {
@@ -196,8 +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 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

@@ -2,7 +2,7 @@ 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,7 +67,7 @@ export interface Municipality {
 }
 export interface DbMunicipalityResult {
     municipality: DbMunicipality;
-    errors: string[];
+    errors: SmdError[];
 }
 export interface MunicipalityWithFounder extends Municipality {
     founder: Founder | null;
@@ -83,7 +83,7 @@ export interface ProcessLineCallbackParams {
     line: string;
 }
 export interface ErrorCallbackParams extends ProcessLineCallbackParams {
-    errors: string[];
+    errors: SmdError[];
 }
 export interface ProcessLineParams {
     line: string;
@@ -92,3 +92,8 @@ export interface ProcessLineParams {
     onError: (params: ErrorCallbackParams) => void;
     onWarning: (params: ErrorCallbackParams) => void;
 }
+export interface SmdError {
+    startOffset: number;
+    endOffset: number;
+    message: string;
+}

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