text-to-map 1.1.16 → 1.1.18

package/README.md

@@ -16,5 +16,54 @@ Text To Map usiluje o lepší, strojově zpracovatelné využití částí vyhl
 
 Pro vyzkoušení je možné použít již vyčištěné vyhlášky ze složky *examples*.
 
+## Street Markdown
+Street Markdown je formát, který po vzoru značkovacího jazyka [Markdown](https://en.wikipedia.org/wiki/Markdown) má za cíl usnadnit psaní strukturovaných dat bez nutnosti učit se složité formátovací tagy nebo používat speciální znaky. Vznikl na základě [pražské spádové vyhlášky z roku 2021](https://www.praha.eu/file/3251117/vyhlaska_c._4.pdf) a snaží se být co nejkompatibilnější s již používaným formátem.
+
+Street Markdown je dále možný rozšiřovat pro další případy použití - například protialkoholová vyhláška (do standardu by byla třeba přidat definice parků), tržní vyhláška, vyhláška o buskingu a další.
+
+### Pravidla Street Markdownu
+
+* **prázdné znaky a řádky**
+    * veškeré po sobě jdoucí mezery jsou ignorovány a počítají se jako jedna mezera
+    * prázdné řádky mají ve formátu speciální význam, několik prázdných řádků za sebou se ignoruje a počítá se jako jeden prázdný řádek
+* **blok oblasti**
+    * v případě SMD pro více obcí či městských částí je uvozen blok oblasti pomocí _názvu oblasti_, následuje prázdný řádek a poté libovolný počet _bloků škol_
+    * _blok oblasti_ končí řádkem před _nadpisem oblasti_ následujícího _bloku obce_ nebo koncem souboru
+* **název oblasti**
+    * začíná znakem "#" následovaný mezerou a textovým řetězcem, který obsahuje přesný název obce
+    * příklady:
+       * \# Praha 1
+       * \# Pelhřimov
+       * \# Poděbrady
+* **blok školy**
+    * jde o souvislý blok bez vynechaných řádků
+    * bloky škol jsou od sebe odděleny jedním či více prázdnými řádky
+* **název školy**
+    * první řádek bloku řádků je název školy
+    * libovolný neprázdný textový řetězec
+* **definice ulice**
+    * definice ulice obsahuje _jméno ulice_ a volitelně _specifikaci orientačních čísel_
+    * pokud celá ulice patří do aktuálního bloku školy, pak se specifikace orientačních čísel neuvádí, uvede se pouze název ulice
+    * název ulice se uvádí v plně rozvinutém tvaru
+        * špatně: nám. Míru, Rašínovo nábř.
+        * správně: náměstí Míru, Rašínovo nábřeží
+    * jméno ulice a specifikace ulice je odděleno znaménkem minus (a volitelnými mezerami okolo pomlčky) - místo minus jsou přípustné i pomlčka a spojovník
+* **specifikace orientačních čísel**
+    * za sebou jdoucí výčet _rozsahů čísel_
+    * _rozsahy čísel_ jsou odděleny čárkou a mezerou (", ") nebo spojkou " a "
+* **rozsah čísel**
+    * jako rozsah čísel se považuje specifikace, zda jde o _typ čísel_ (všechna, sudá či lichá čísla) a _rozsah_ od-do, a to v následujícím formátu:
+        * **typ čísel**
+            * všechna = "č."
+            * lichá = "lichá č."
+            * sudá = "sudá č."
+            * čísla popisná = "č. p."
+        * **rozsah čísel**
+            * může jít o výčet (oddělený ", " nebo " a ") těchto možností:
+                * a) <číslo>, např. 7
+                * b) <číslo>-<číslo>, např. 2-66 (přípustné jsou pomlčka, spojovník, minus)
+                * c) (od) <číslo> (a) výše, např. od 20 výše, 14 a výše, od 7 a výše
+                * d) do (č.) <číslo>
+            * např. 1-9, 11, od 23 výše
 
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/E1E5JOMLT)

package/dist/bin/parse-ordinance.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { readFileSync, writeFileSync } from "fs";
-import { getNewMunicipality, parseOrdinanceToAddressPoints, } from "../street-markdown/smd";
+import { getNewMunicipalityByName, parseOrdinanceToAddressPoints, } from "../street-markdown/smd";
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         // take first node argument as a file name
@@ -35,7 +35,7 @@ function main() {
             warningCount++;
         };
         console.time("downloadAndImportAllLatestAddressPoints");
-        const { municipality } = yield getNewMunicipality("Česká Lípa");
+        const { municipality } = yield getNewMunicipalityByName("Česká Lípa");
         const addressPoints = yield parseOrdinanceToAddressPoints(lines, {
         // currentMunicipality: municipality,
         }, reportErrors, reportWarnings);

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

@@ -33,27 +33,26 @@ export declare const checkStreetExists: (streetName: string, founder: Founder) =
     exists: boolean;
     errors: SmdError[];
 }>;
-export declare enum FindAddressPointsType {
-    SmdLine = 0,
-    MunicipalityPart = 1,
-    WholeMunicipality = 2,
-    WholeMunicipalityNoStreetName = 3
-}
 export type FindAddressPointsParams = {
-    type: FindAddressPointsType.SmdLine;
+    type: "smdLine";
     smdLine: SmdLine;
     municipality: Municipality;
+    municipalityPartCode?: number;
 } | {
-    type: FindAddressPointsType.MunicipalityPart;
+    type: "wholeMunicipalityPart";
     municipalityPartCode: number;
 } | {
-    type: FindAddressPointsType.WholeMunicipality;
+    type: "wholeMunicipality";
     municipality: Municipality;
 } | {
-    type: FindAddressPointsType.WholeMunicipalityNoStreetName;
+    type: "wholeMunicipalityNoStreetName";
     municipality: Municipality;
 };
 export declare const findAddressPoints: (params: FindAddressPointsParams) => Promise<AddressPoint[]>;
+export declare const filterAddressPoints: (addressPoints: AddressPoint[], params: FindAddressPointsParams) => AddressPoint[];
+export declare const getQueryParams: (params: FindAddressPointsParams) => (string | number)[];
+export declare const getStreetJoinCondition: (params: FindAddressPointsParams) => string;
+export declare const getWhereCondition: (params: FindAddressPointsParams) => string;
 export declare const isInRange: (number: number | null, letter: string | null, range: RangeSpec) => boolean;
 export declare const fitsType: (number: number | null, type: SeriesType) => boolean;
 export declare const equalsFullStreetNumber: (fullStreetNumber: FullStreetNumber, addressPoint: AddressPoint) => boolean;

package/dist/db/address-points.js

@@ -183,29 +183,11 @@ const getAllStreets = (cityCode) => __awaiter(void 0, void 0, void 0, function*
     const knex = getKnexDb();
     return yield knex.pluck("name").from("street").where("city_code", cityCode);
 });
-export var FindAddressPointsType;
-(function (FindAddressPointsType) {
-    FindAddressPointsType[FindAddressPointsType["SmdLine"] = 0] = "SmdLine";
-    FindAddressPointsType[FindAddressPointsType["MunicipalityPart"] = 1] = "MunicipalityPart";
-    FindAddressPointsType[FindAddressPointsType["WholeMunicipality"] = 2] = "WholeMunicipality";
-    FindAddressPointsType[FindAddressPointsType["WholeMunicipalityNoStreetName"] = 3] = "WholeMunicipalityNoStreetName";
-})(FindAddressPointsType || (FindAddressPointsType = {}));
 export const findAddressPoints = (params) => __awaiter(void 0, void 0, void 0, function* () {
     const knex = getKnexDb();
-    const queryParams = params.type === FindAddressPointsType.SmdLine
-        ? [params.smdLine.street, params.municipality.code]
-        : params.type === FindAddressPointsType.MunicipalityPart
-            ? [params.municipalityPartCode]
-            : [params.municipality.code];
-    const streetJoinCondition = params.type === FindAddressPointsType.SmdLine
-        ? `JOIN street s ON a.street_code = s.code AND s.name = ? ${isSqlite(knex) ? "COLLATE NOCASE" : ""}`
-        : "LEFT JOIN street s ON a.street_code = s.code";
-    const whereCondition = params.type === FindAddressPointsType.MunicipalityPart
-        ? "a.municipality_part_code = ?"
-        : getMunicipalityWhere("a", params.municipality) +
-            (params.type === FindAddressPointsType.WholeMunicipalityNoStreetName
-                ? " AND a.street_code IS NULL"
-                : "");
+    const queryParams = getQueryParams(params);
+    const streetJoinCondition = getStreetJoinCondition(params);
+    const whereCondition = getWhereCondition(params);
     const queryResult = yield rawQuery(`SELECT a.id, s.name AS street_name, o.name AS object_type_name, a.descriptive_number,
       a.orientational_number, a.orientational_number_letter, c.name AS city_name,
       d.name AS district_name, m.name AS municipality_part_name, p.name AS prague_district_name,
@@ -218,28 +200,32 @@ export const findAddressPoints = (params) => __awaiter(void 0, void 0, void 0, f
     LEFT JOIN municipality_part m ON a.municipality_part_code = m.code
     LEFT JOIN prague_district p ON a.prague_district_code = p.code
     WHERE ${whereCondition}`, queryParams);
-    const filteredAddressPoints = queryResult.map(rowToAddressPoint);
-    if (params.type !== FindAddressPointsType.SmdLine) {
-        return filteredAddressPoints;
+    return filterAddressPoints(queryResult.map(rowToAddressPoint), params);
+});
+export const filterAddressPoints = (addressPoints, params) => {
+    if (params.type === "wholeMunicipality" ||
+        params.type === "wholeMunicipalityNoStreetName" ||
+        params.type === "wholeMunicipalityPart") {
+        return addressPoints;
     }
     const result = [];
     const numberSpec = params.smdLine.numberSpec;
     if (isSeriesSpecArray(numberSpec)) {
         numberSpec.forEach((seriesSpec) => {
-            result.push(...filterAddressPointsByRanges(filteredAddressPoints, seriesSpec));
+            result.push(...filterAddressPointsByRanges(addressPoints, seriesSpec));
         });
         // when no number specs are present, we take everything
         if (numberSpec.length === 0) {
-            result.push(...filteredAddressPoints);
+            result.push(...addressPoints);
         }
     }
     else if (isNegativeSeriesSpec(numberSpec)) {
         // negative number spec (e.g. odd numbers except 13-17)
-        const toExclude = filterAddressPointsByRanges(filteredAddressPoints, numberSpec);
-        result.push(...filteredAddressPoints.filter((addressPoint) => !toExclude.includes(addressPoint)));
+        const toExclude = filterAddressPointsByRanges(addressPoints, numberSpec);
+        result.push(...addressPoints.filter((addressPoint) => !toExclude.includes(addressPoint)));
     }
     return result;
-});
+};
 const filterAddressPointsByRanges = (addressPoints, seriesSpec) => {
     const result = [];
     seriesSpec.ranges.forEach((range) => {
@@ -263,6 +249,32 @@ const filterAddressPointsByRanges = (addressPoints, seriesSpec) => {
     }
     return result;
 };
+export const getQueryParams = (params) => {
+    if (params.type === "smdLine" && params.smdLine.type === "street") {
+        return [params.smdLine.street, params.municipality.code];
+    }
+    if ((params.type === "smdLine" && params.smdLine.type === "municipalityPart") ||
+        params.type === "wholeMunicipalityPart") {
+        return [params.municipalityPartCode];
+    }
+    return [params.municipality.code];
+};
+export const getStreetJoinCondition = (params) => {
+    if (params.type === "smdLine" && params.smdLine.type === "street") {
+        return `JOIN street s ON a.street_code = s.code AND s.name = ? ${isSqlite(getKnexDb()) ? "COLLATE NOCASE" : ""}`;
+    }
+    return "LEFT JOIN street s ON a.street_code = s.code";
+};
+export const getWhereCondition = (params) => {
+    if ((params.type === "smdLine" && params.smdLine.type === "municipalityPart") ||
+        params.type === "wholeMunicipalityPart") {
+        return "a.municipality_part_code = ?";
+    }
+    if (params.type === "wholeMunicipalityNoStreetName") {
+        return `${getMunicipalityWhere("a", params.municipality)} AND a.street_code IS NULL`;
+    }
+    return getMunicipalityWhere("a", params.municipality);
+};
 export const isInRange = (number, letter, range) => {
     if (number === null) {
         return !range.from && !range.to;

package/dist/db/founders.d.ts

@@ -1,6 +1,10 @@
 import { DbMunicipalityResult, MunicipalityPartResult, SmdError } from "../street-markdown/types";
 import { Founder, MunicipalityType } from "./types";
 export declare const insertFounders: (founders: Founder[]) => Promise<number>;
+export declare const getFounderById: (id: number) => Promise<{
+    founder: Founder;
+    errors: SmdError[];
+}>;
 export declare const findFounder: (nameWithHashtag: string) => Promise<{
     founder: Founder;
     errors: SmdError[];

package/dist/db/founders.js

@@ -223,14 +223,27 @@ const extractFounderName = (line) => {
         return line.trim();
     }
 };
-export const findFounder = (nameWithHashtag) => __awaiter(void 0, void 0, void 0, function* () {
-    const errors = [];
-    const name = extractFounderName(nameWithHashtag);
-    const result = yield getKnexDb()
+const getBaseFounderQuery = () => {
+    return getKnexDb()
         .select("f.id", "f.name", "f.ico", "f.founder_type_code", "f.city_code", "f.city_district_code")
         .from("founder as f")
         .leftJoin("city as c", "c.code", "f.city_code")
-        .leftJoin("city_district as d", "d.code", "f.city_district_code")
+        .leftJoin("city_district as d", "d.code", "f.city_district_code");
+};
+export const getFounderById = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield getBaseFounderQuery().where("f.id", id).first();
+    const founder = yield resultToFounder(result);
+    return {
+        founder: founder !== null && founder !== void 0 ? founder : null,
+        errors: founder
+            ? []
+            : [wholeLineError(`Zřizovatel s id ${id} neexistuje.`, "")],
+    };
+});
+export const findFounder = (nameWithHashtag) => __awaiter(void 0, void 0, void 0, function* () {
+    const errors = [];
+    const name = extractFounderName(nameWithHashtag);
+    const result = yield getBaseFounderQuery()
         .where("f.name", name)
         .orWhere("c.name", name)
         .orWhere("d.name", name)

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

@@ -1,9 +1,11 @@
 import { Founder } from "../db/types";
 import { DbMunicipalityResult, MunicipalityPartResult } from "./types";
-export declare const isMunicipalityPart: (line: string) => boolean;
-export declare const getMunicipalityPart: (line: string, founder: Founder) => Promise<MunicipalityPartResult>;
 export declare const isMunicipalitySwitch: (line: string) => boolean;
 export declare const getSwitchMunicipality: (line: string, founder: Founder) => Promise<DbMunicipalityResult>;
 export declare const isWholeMunicipality: (line: string) => boolean;
-export declare const isNoStreetNameLine: (line: string) => boolean;
+export declare const isRestWithNoStreetNameLine: (line: string) => boolean;
+export declare const isRestOfMunicipalityLine: (line: string) => boolean;
+export declare const isRestOfMunicipalityPartLine: (line: string) => boolean;
+export declare const getRestOfMunicipalityPart: (line: string, founder: Founder) => Promise<MunicipalityPartResult>;
 export declare const getWholeMunicipality: (line: string, founder: Founder) => Promise<DbMunicipalityResult>;
+export declare const getMunicipalityPartResult: (name: string, line: string, founder: Founder) => Promise<MunicipalityPartResult>;

package/dist/street-markdown/municipality.js

@@ -9,32 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { findMunicipalityByNameAndType, findMunicipalityPartByName, } from "../db/founders";
 import { MunicipalityType } from "../db/types";
-const municipalityPartPattern = /^část (?<type>obce|města) (?<name>.+)$/;
 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>.+)$/;
-const noStreetNamePattern = /^všechny ostatní budovy bez názvu ulice\s*$/;
-export const isMunicipalityPart = (line) => {
-    return municipalityPartPattern.test(line);
-};
-export const getMunicipalityPart = (line, founder) => __awaiter(void 0, void 0, void 0, function* () {
-    const match = municipalityPartPattern.exec(line);
-    if (match === null) {
-        return {
-            errors: [
-                {
-                    message: "Neplatný zápis pro přidání části obce. Správný zápis je: části <obce/města> <název části obce>. Např.: 'části obce Kladno' (název části obce musí být v 1. pádě).",
-                    startOffset: 0,
-                    endOffset: line.length + 1,
-                },
-            ],
-            municipalityPartCode: null,
-        };
-    }
-    const { name } = match.groups;
-    return yield getMunicipalityPartResult(cleanName(name), line, founder);
-});
+const restWithNoStreetNamePattern = /^všechny ostatní budovy bez názvu ulice\s*$/;
+const restOfMunicipalityPattern = /^zbytek (?<type>městské části|městského obvodu|obce|města)\s*$/;
+const restOfMunicipalityPartPattern = /^zbytek části (obce|města) (?<name>.+)\s*$/;
 export const isMunicipalitySwitch = (line) => {
     return municipalitySwitchStartPattern.test(line);
 };
@@ -58,9 +39,32 @@ export const getSwitchMunicipality = (line, founder) => __awaiter(void 0, void 0
 export const isWholeMunicipality = (line) => {
     return wholeMunicipalityStartPattern.test(line);
 };
-export const isNoStreetNameLine = (line) => {
-    return noStreetNamePattern.test(line);
+export const isRestWithNoStreetNameLine = (line) => {
+    return restWithNoStreetNamePattern.test(line);
+};
+export const isRestOfMunicipalityLine = (line) => {
+    return restOfMunicipalityPattern.test(line);
 };
+export const isRestOfMunicipalityPartLine = (line) => {
+    return restOfMunicipalityPartPattern.test(line);
+};
+export const getRestOfMunicipalityPart = (line, founder) => __awaiter(void 0, void 0, void 0, function* () {
+    const match = restOfMunicipalityPartPattern.exec(line);
+    if (match === null) {
+        return {
+            errors: [
+                {
+                    message: "Neplatný zápis pro přidání zbytku části obce. Správný zápis je: zbytek části <typ> <název obce>. Např.: 'zbytek části obce Malšovice' (název části obce musí být v 1. pádě).",
+                    startOffset: 0,
+                    endOffset: line.length + 1,
+                },
+            ],
+            municipalityPartCode: null,
+        };
+    }
+    const { name } = match.groups;
+    return yield getMunicipalityPartResult(name, line, founder);
+});
 export const getWholeMunicipality = (line, founder) => __awaiter(void 0, void 0, void 0, function* () {
     const match = wholeMunicipalityPattern.exec(line);
     if (match === null) {
@@ -89,7 +93,7 @@ const getMunicipalityResult = (type, name, line, founder) => __awaiter(void 0, v
             endOffset }))),
     };
 });
-const getMunicipalityPartResult = (name, line, founder) => __awaiter(void 0, void 0, void 0, function* () {
+export const getMunicipalityPartResult = (name, line, founder) => __awaiter(void 0, void 0, void 0, function* () {
     const { municipalityPartCode, errors } = yield findMunicipalityPartByName(name, founder);
     const startOffset = line.indexOf(name);
     const endOffset = startOffset + name.length + 1;

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

@@ -4,6 +4,7 @@ export declare class SmdParser extends EmbeddedActionsParser {
     constructor(tokenVocabulary: TokenVocabulary);
     street: import("chevrotain").ParserMethod<[], SmdLine[]>;
     private streetNameAndNumbersSpecs;
+    private municipalityPartNameAndNumbersSpecs;
     private numberSpecs;
     private seriesSpecs;
     private _gatePostfixTypeSeriesSpec;
@@ -19,3 +20,4 @@ export declare class SmdParser extends EmbeddedActionsParser {
     private fullStreetNumber;
 }
 export declare const parseRichNumber: (number: string) => RichNumber;
+export declare const parseMunicipalityPartName: (name: string) => string;

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

@@ -1,6 +1,6 @@
 import { EmbeddedActionsParser, EOF } from "chevrotain";
 import { splitStreetViaRomanNumerals } from "./roman-numerals";
-import { MainSeparator, Separator, OddType, EvenType, DescriptiveType, AllType, Number, Hyphen, StreetName, From, To, AndAbove, AndBelow, Slash, Without, } from "./token-definition";
+import { AllType, AndAbove, AndBelow, DescriptiveType, EvenType, From, Hyphen, MainSeparator, MunicipalityPartName, Number, OddType, Separator, Slash, StreetName, To, Without, } from "./token-definition";
 import { SeriesType } from "./types";
 export class SmdParser extends EmbeddedActionsParser {
     constructor(tokenVocabulary) {
@@ -15,14 +15,39 @@ export class SmdParser extends EmbeddedActionsParser {
                 },
                 {
                     ALT: () => {
-                        result = { street: this.CONSUME(StreetName).image, numberSpec: [] };
+                        result = {
+                            type: "street",
+                            street: this.CONSUME(StreetName).image,
+                            numberSpec: [],
+                        };
+                    },
+                },
+                {
+                    ALT: () => {
+                        result = this.SUBRULE(this.municipalityPartNameAndNumbersSpecs);
+                    },
+                },
+                {
+                    ALT: () => {
+                        const municipalityPart = parseMunicipalityPartName(this.CONSUME(MunicipalityPartName).image);
+                        result = {
+                            type: "municipalityPart",
+                            municipalityPart,
+                            numberSpec: [],
+                        };
                     },
                 },
             ]);
-            return splitStreetViaRomanNumerals(result.street).map((street) => ({
-                street,
-                numberSpec: result.numberSpec,
-            }));
+            if (result.type === "street") {
+                return splitStreetViaRomanNumerals(result.street).map((street) => ({
+                    type: "street",
+                    street,
+                    numberSpec: result.numberSpec,
+                }));
+            }
+            else {
+                return [result];
+            }
         });
         this.streetNameAndNumbersSpecs = this.RULE("streetNameAndNumbersSpecs", () => {
             const street = this.CONSUME(StreetName).image;
@@ -30,10 +55,23 @@ export class SmdParser extends EmbeddedActionsParser {
                 this.CONSUME(MainSeparator);
             });
             const numberSpec = this.SUBRULE(this.numberSpecs);
-            return { street, numberSpec };
+            return { type: "street", street, numberSpec };
+        });
+        this.municipalityPartNameAndNumbersSpecs = this.RULE("municipalityPartNameAndNumbersSpecs", () => {
+            const municipalityPart = parseMunicipalityPartName(this.CONSUME(MunicipalityPartName).image);
+            this.OPTION(() => {
+                this.CONSUME(MainSeparator);
+            });
+            const numberSpec = this.SUBRULE(this.numberSpecs);
+            return {
+                type: "municipalityPart",
+                municipalityPart,
+                numberSpec,
+            };
         });
         this.numberSpecs = this.RULE("numberSpecs", () => {
-            const result = [];
+            const positiveResult = [];
+            let negativeResult;
             this.OR([
                 {
                     GATE: () => this.LA(2).tokenType === Without,
@@ -55,14 +93,14 @@ export class SmdParser extends EmbeddedActionsParser {
                                 GATE: this._gatePostfixTypeSeriesSpec,
                                 ALT: () => {
                                     const { type, ranges } = this.SUBRULE(this.postfixTypeSeriesSpec);
-                                    return { negative: true, type, ranges };
+                                    negativeResult = { negative: true, type, ranges };
                                 },
                             },
                             {
                                 ALT: () => {
                                     const type = this.SUBRULE2(this.seriesType);
                                     const ranges = this.SUBRULE2(this.rangeList);
-                                    return { negative: true, type, ranges };
+                                    negativeResult = { negative: true, type, ranges };
                                 },
                             },
                         ]);
@@ -73,13 +111,16 @@ export class SmdParser extends EmbeddedActionsParser {
                         this.AT_LEAST_ONE_SEP({
                             SEP: Separator,
                             DEF: () => {
-                                result.push(this.SUBRULE(this.seriesSpecs));
+                                positiveResult.push(this.SUBRULE(this.seriesSpecs));
                             },
                         });
                     },
                 },
             ]);
-            return result;
+            if (negativeResult) {
+                return negativeResult;
+            }
+            return positiveResult;
         });
         this.seriesSpecs = this.RULE("seriesSpecs", () => {
             let ranges = [];
@@ -321,7 +362,10 @@ export class SmdParser extends EmbeddedActionsParser {
             const descriptiveNumber = parseRichNumber(this.CONSUME(Number).image);
             this.CONSUME(Slash);
             const orientationNumber = parseRichNumber(this.CONSUME2(Number).image);
-            return { descriptionNumber: descriptiveNumber, orientationalNumber: orientationNumber };
+            return {
+                descriptionNumber: descriptiveNumber,
+                orientationalNumber: orientationNumber,
+            };
         });
         this.performSelfAnalysis();
     }
@@ -341,3 +385,9 @@ export const parseRichNumber = (number) => {
         };
     }
 };
+const municipalityPartPattern = /^část (?<type>obce|města) (?<name>.+)$/;
+export const parseMunicipalityPartName = (name) => {
+    var _a, _b;
+    const match = municipalityPartPattern.exec(name);
+    return (_b = (_a = match === null || match === void 0 ? void 0 : match.groups.name) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "";
+};

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

@@ -2,7 +2,11 @@ import { Founder } from "../db/types";
 import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, ProcessLineCallbackParams, School, SmdError, SmdState } from "./types";
 export declare const parseOrdinanceToAddressPoints: (lines: string[], initialState?: Partial<SmdState>, onError?: (params: ErrorCallbackParams) => void, onWarning?: (params: ErrorCallbackParams) => void, onProcessedLine?: (params: ProcessLineCallbackParams) => void) => Promise<Municipality[]>;
 export declare const convertMunicipality: (municipality: MunicipalityWithFounder) => Municipality;
-export declare const getNewMunicipality: (name: string) => Promise<{
+export declare const getNewMunicipalityByName: (name: string) => Promise<{
+    municipality: MunicipalityWithFounder;
+    errors: SmdError[];
+}>;
+export declare const getNewMunicipalityByFounderId: (founderId: number) => Promise<{
     municipality: MunicipalityWithFounder;
     errors: SmdError[];
 }>;

package/dist/street-markdown/smd.js

@@ -7,17 +7,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { FindAddressPointsType, checkStreetExists, findAddressPoints, getAddressPointById, } from "../db/address-points";
+import { checkStreetExists, findAddressPoints, getAddressPointById, } from "../db/address-points";
 import { disconnectKnex } from "../db/db";
-import { findFounder } from "../db/founders";
+import { findFounder, getFounderById } from "../db/founders";
 import { findSchool } from "../db/schools";
 import { founderToMunicipality } from "../db/types";
-import { getMunicipalityPart, getSwitchMunicipality, getWholeMunicipality, isMunicipalityPart, isMunicipalitySwitch, isNoStreetNameLine, isWholeMunicipality, } from "./municipality";
+import { getMunicipalityPartResult, getRestOfMunicipalityPart, getSwitchMunicipality, getWholeMunicipality, isMunicipalitySwitch, isRestOfMunicipalityLine, isRestOfMunicipalityPartLine, isRestWithNoStreetNameLine, isWholeMunicipality, } from "./municipality";
 import { parseLine } from "./smd-line-parser";
 import { isAddressPoint, } from "./types";
 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, noStreetNameSchoolIzo: null, municipalities: [] }, initialState);
+        const state = Object.assign({ currentMunicipality: null, currentFilterMunicipality: null, currentSchool: null, rests: {
+                noStreetNameSchoolIzo: null,
+                municipalityParts: [],
+                wholeMunicipalitySchoolIzo: null,
+            }, municipalities: [] }, initialState);
         let lineNumber = 1;
         for (const rawLine of lines) {
             const line = cleanLine(rawLine);
@@ -37,12 +41,7 @@ export const parseOrdinanceToAddressPoints = (lines, initialState = {}, onError
             }
             state.currentMunicipality.schools.push(mapSchoolForExport(state.currentSchool));
         }
-        if (state.currentMunicipality != null) {
-            if (state.noStreetNameSchoolIzo) {
-                yield addNoStreetNameToSchool(state);
-            }
-            state.municipalities.push(convertMunicipality(state.currentMunicipality));
-        }
+        yield completeCurrentMunicipality(state);
         return state.municipalities;
     }
     catch (error) {
@@ -82,17 +81,29 @@ const processOneLine = (params) => __awaiter(void 0, void 0, void 0, function* (
         yield processSchoolLine(params);
         return;
     }
-    if (isMunicipalityPart(line)) {
-        yield processMunicipalityPartLine(params);
-    }
-    else if (isMunicipalitySwitch(line)) {
+    if (isMunicipalitySwitch(line)) {
         processMunicipalitySwitchLine(params);
     }
     else if (isWholeMunicipality(line)) {
         yield processWholeMunicipalityLine(params);
     }
-    else if (isNoStreetNameLine(line)) {
-        state.noStreetNameSchoolIzo = state.currentSchool.izo;
+    else if (isRestWithNoStreetNameLine(line)) {
+        state.rests.noStreetNameSchoolIzo = state.currentSchool.izo;
+    }
+    else if (isRestOfMunicipalityLine(line)) {
+        state.rests.wholeMunicipalitySchoolIzo = state.currentSchool.izo;
+    }
+    else if (isRestOfMunicipalityPartLine(line)) {
+        const { municipalityPartCode, errors } = yield getRestOfMunicipalityPart(line, state.currentMunicipality.founder);
+        if (errors.length > 0) {
+            params.onError({ lineNumber: params.lineNumber, line, errors });
+        }
+        else {
+            state.rests.municipalityParts.push({
+                municipalityPartCode,
+                schoolIzo: state.currentSchool.izo,
+            });
+        }
     }
     else {
         yield processAddressPointLine(params);
@@ -103,13 +114,8 @@ const processMunicipalityLine = ({ line, lineNumber, state, onError, }) => __awa
         state.currentMunicipality.schools.push(state.currentSchool);
         state.currentSchool = null;
     }
-    if (state.currentMunicipality !== null) {
-        if (state.noStreetNameSchoolIzo) {
-            yield addNoStreetNameToSchool(state);
-        }
-        state.municipalities.push(convertMunicipality(state.currentMunicipality));
-    }
-    const { municipality, errors } = yield getNewMunicipality(line);
+    yield completeCurrentMunicipality(state);
+    const { municipality, errors } = yield getNewMunicipalityByName(line);
     if (errors.length > 0) {
         onError({ lineNumber, line, errors });
     }
@@ -117,6 +123,12 @@ const processMunicipalityLine = ({ line, lineNumber, state, onError, }) => __awa
     state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
     state.currentSchool = null;
 });
+const completeCurrentMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
+    if (state.currentMunicipality !== null) {
+        yield addRests(state);
+        state.municipalities.push(convertMunicipality(state.currentMunicipality));
+    }
+});
 const processEmptyLine = ({ state }) => {
     if (state.currentSchool !== null) {
         state.currentMunicipality.schools.push(state.currentSchool);
@@ -137,19 +149,6 @@ const processSchoolLine = ({ line, lineNumber, state, onError, }) => __awaiter(v
     state.currentSchool = yield getNewSchool(line, state.currentMunicipality.founder, lineNumber, onError);
     state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
 });
-const processMunicipalityPartLine = ({ line, state, lineNumber, onError, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { municipalityPartCode, errors } = yield getMunicipalityPart(line, state.currentMunicipality.founder);
-    if (errors.length > 0) {
-        onError({ lineNumber, line, errors });
-    }
-    else {
-        const addressPoints = yield findAddressPoints({
-            type: FindAddressPointsType.MunicipalityPart,
-            municipalityPartCode,
-        });
-        state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
-    }
-});
 const processMunicipalitySwitchLine = ({ line, state, lineNumber, onError, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { municipality, errors } = yield getSwitchMunicipality(line, state.currentMunicipality.founder);
     if (errors.length > 0) {
@@ -166,7 +165,7 @@ const processWholeMunicipalityLine = ({ line, state, lineNumber, onError, }) =>
     }
     else {
         const addressPoints = yield findAddressPoints({
-            type: FindAddressPointsType.WholeMunicipality,
+            type: "wholeMunicipality",
             municipality,
         });
         state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
@@ -179,48 +178,105 @@ const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning,
     }
     else {
         for (const smdLine of smdLines) {
-            const { exists, errors } = yield checkStreetExists(smdLine.street, state.currentMunicipality.founder);
-            if (errors.length > 0) {
-                onWarning({ lineNumber, line, errors });
+            if (smdLine.type === "street") {
+                const { exists, errors } = yield checkStreetExists(smdLine.street, state.currentMunicipality.founder);
+                if (errors.length > 0) {
+                    onWarning({ lineNumber, line, errors });
+                }
+                if (exists) {
+                    const addressPoints = yield findAddressPoints({
+                        type: "smdLine",
+                        smdLine,
+                        municipality: state.currentFilterMunicipality,
+                    });
+                    state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+                }
             }
-            if (exists) {
-                let addressPoints = yield findAddressPoints({
-                    type: FindAddressPointsType.SmdLine,
-                    smdLine,
-                    municipality: state.currentFilterMunicipality,
-                });
-                state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+            else if (smdLine.type === "municipalityPart") {
+                const { municipalityPartCode, errors } = yield getMunicipalityPartResult(smdLine.municipalityPart, line, state.currentMunicipality.founder);
+                if (errors.length > 0) {
+                    onWarning({ lineNumber, line, errors });
+                }
+                else {
+                    const addressPoints = yield findAddressPoints({
+                        type: "smdLine",
+                        smdLine,
+                        municipality: state.currentFilterMunicipality,
+                        municipalityPartCode,
+                    });
+                    state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+                }
             }
         }
     }
 });
-const addNoStreetNameToSchool = (state) => __awaiter(void 0, void 0, void 0, function* () {
+const addRestToSchool = (restPoints, schoolIzo, state) => __awaiter(void 0, void 0, void 0, function* () {
     const addressPoints = state.currentMunicipality.schools.flatMap((school) => school.addresses);
+    // filter out address points already present
+    const remainingPoints = restPoints.filter((point) => !addressPoints.some((ap) => ap.address === point.address));
+    // find the right school and add the remaining address points
+    const schoolIndex = state.currentMunicipality.schools.findIndex((school) => school.izo === schoolIzo);
+    state.currentMunicipality.schools[schoolIndex].addresses.push(...remainingPoints);
+});
+const addRests = (state) => __awaiter(void 0, void 0, void 0, function* () {
+    if (state.rests.noStreetNameSchoolIzo) {
+        yield addRestWithNoStreetNameToSchool(state);
+    }
+    if (state.rests.wholeMunicipalitySchoolIzo) {
+        yield addRestOfMunicipality(state);
+    }
+    for (const rest of state.rests.municipalityParts) {
+        yield addRestOfMunicipalityPart(state, rest.municipalityPartCode, rest.schoolIzo);
+    }
+    state.rests.noStreetNameSchoolIzo = null;
+    state.rests.wholeMunicipalitySchoolIzo = null;
+    state.rests.municipalityParts = [];
+});
+const addRestWithNoStreetNameToSchool = (state) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points without street name for current municipality
     const pointsNoStreetName = yield findAddressPoints({
-        type: FindAddressPointsType.WholeMunicipalityNoStreetName,
+        type: "wholeMunicipalityNoStreetName",
         municipality: {
             code: state.currentMunicipality.founder.cityOrDistrictCode,
             type: state.currentMunicipality.founder.municipalityType,
         },
     });
-    // filter out address points already present
-    const remainingPoints = pointsNoStreetName.filter((point) => !addressPoints.some((ap) => ap.address === point.address));
-    // find the right school and add the remaining address points
-    const schoolIndex = state.currentMunicipality.schools.findIndex((school) => school.izo === state.noStreetNameSchoolIzo);
-    state.currentMunicipality.schools[schoolIndex].addresses.push(...remainingPoints);
-    state.noStreetNameSchoolIzo = null;
+    yield addRestToSchool(pointsNoStreetName, state.rests.noStreetNameSchoolIzo, state);
 });
-export const getNewMunicipality = (name) => __awaiter(void 0, void 0, void 0, function* () {
-    const { founder, errors } = yield findFounder(name);
-    return {
+const addRestOfMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
+    // get all address points for current municipality
+    const allPoints = yield findAddressPoints({
+        type: "wholeMunicipality",
         municipality: {
-            municipalityName: founder ? founder.name : "Neznámá obec",
-            founder,
-            schools: [],
+            code: state.currentMunicipality.founder.cityOrDistrictCode,
+            type: state.currentMunicipality.founder.municipalityType,
         },
-        errors,
-    };
+    });
+    yield addRestToSchool(allPoints, state.rests.wholeMunicipalitySchoolIzo, state);
+});
+const addRestOfMunicipalityPart = (state, municipalityPartCode, schoolIzo) => __awaiter(void 0, void 0, void 0, function* () {
+    // get all address points for current municipality
+    const allPoints = yield findAddressPoints({
+        type: "wholeMunicipalityPart",
+        municipalityPartCode,
+    });
+    yield addRestToSchool(allPoints, schoolIzo, state);
+});
+export const getNewMunicipalityByName = (name) => __awaiter(void 0, void 0, void 0, function* () {
+    const { founder, errors } = yield findFounder(name);
+    return getNewMunicipality(founder, errors);
+});
+export const getNewMunicipalityByFounderId = (founderId) => __awaiter(void 0, void 0, void 0, function* () {
+    const { founder, errors } = yield getFounderById(founderId);
+    return getNewMunicipality(founder, errors);
+});
+const getNewMunicipality = (founder, errors) => ({
+    municipality: {
+        municipalityName: founder ? founder.name : "Neznámá obec",
+        founder,
+        schools: [],
+    },
+    errors,
 });
 export const getNewSchool = (name, founder, lineNumber, onError) => __awaiter(void 0, void 0, void 0, function* () {
     let exportSchool = {

package/dist/street-markdown/token-definition.d.ts

@@ -1,6 +1,7 @@
 import { TokenVocabulary } from "chevrotain";
 export declare const resetTokenState: () => void;
 export declare const prepareLine: (text: string) => string;
+export declare const nameMatcherFactory: (pattern: RegExp) => (text: string, startOffset: number) => RegExpExecArray | [string] | null;
 export declare const streetNameMatcher: (text: string, startOffset: number) => RegExpExecArray | [string] | null;
 declare const MainSeparator: import("chevrotain").TokenType;
 declare const From: import("chevrotain").TokenType;
@@ -13,6 +14,7 @@ declare const AllType: import("chevrotain").TokenType;
 declare const OddType: import("chevrotain").TokenType;
 declare const EvenType: import("chevrotain").TokenType;
 declare const Without: import("chevrotain").TokenType;
+declare const MunicipalityPartName: import("chevrotain").TokenType;
 declare const StreetName: import("chevrotain").TokenType;
 declare const Number: import("chevrotain").TokenType;
 declare const Hyphen: import("chevrotain").TokenType;
@@ -20,4 +22,4 @@ declare const Slash: import("chevrotain").TokenType;
 declare const Space: import("chevrotain").TokenType;
 declare const smdTokens: import("chevrotain").TokenType[];
 declare const tokenVocabulary: TokenVocabulary;
-export { MainSeparator, Separator, OddType, EvenType, DescriptiveType, AllType, Number, From, To, AndAbove, AndBelow, Without, Hyphen, Slash, Space, StreetName, smdTokens, tokenVocabulary, };
+export { MainSeparator, Separator, OddType, EvenType, DescriptiveType, AllType, Number, From, To, AndAbove, AndBelow, Without, Hyphen, Slash, Space, StreetName, MunicipalityPartName, smdTokens, tokenVocabulary, };

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

@@ -1,7 +1,7 @@
 import { createToken, Lexer } from "chevrotain";
-let streetNameWasMatched = false;
+let nameWasMatched = false;
 export const resetTokenState = () => {
-    streetNameWasMatched = false;
+    nameWasMatched = false;
 };
 export const prepareLine = (text) => {
     return text
@@ -9,10 +9,12 @@ export const prepareLine = (text) => {
         .replace(/;/g, ",")
         .replace(/,$/, "");
 };
+// this function prevents numbers that make part of the street name to be matched before the
+// street/municipality part name is completely matched
 const tokenBlockerFactory = (pattern) => {
     const stickyPattern = new RegExp(pattern, "y");
     return (text, startOffset) => {
-        if (streetNameWasMatched) {
+        if (nameWasMatched) {
             stickyPattern.lastIndex = startOffset;
             return stickyPattern.exec(text);
         }
@@ -35,26 +37,32 @@ const interruptPatterns = [
     "s výjimkou",
     "kromě",
 ];
+// this pattern allows a single space or a single hyphen (without an adjacent space) between words
 const streetNamePattern = /[^ -]+([ -]?[^ -]+)*/;
-export const streetNameMatcher = (text, startOffset) => {
-    if (streetNameWasMatched || startOffset > 0) {
-        return null;
-    }
-    else {
-        const result = streetNamePattern.exec(text);
-        if (result !== null) {
-            streetNameWasMatched = true;
-            const firstIndex = interruptPatterns.reduce((currentMin, pattern) => {
-                const index = text.search(new RegExp(` ${pattern}( |$)`));
-                return index >= 0 ? Math.min(index, currentMin) : currentMin;
-            }, Infinity);
-            if (firstIndex < Infinity) {
-                return [result[0].substring(0, firstIndex).trim()];
+// same but with a prefix of municipality part
+const municipalityPartNamePattern = /část (obce|města) [^ -]+([ -]?[^ -]+)*/;
+export const nameMatcherFactory = (pattern) => {
+    return (text, startOffset) => {
+        if (nameWasMatched || startOffset > 0) {
+            return null;
+        }
+        else {
+            const result = pattern.exec(text);
+            if (result !== null) {
+                nameWasMatched = true;
+                const firstIndex = interruptPatterns.reduce((currentMin, pattern) => {
+                    const index = text.search(new RegExp(` ${pattern}( |$)`));
+                    return index >= 0 ? Math.min(index, currentMin) : currentMin;
+                }, Infinity);
+                if (firstIndex < Infinity) {
+                    return [result[0].substring(0, firstIndex).trim()];
+                }
             }
+            return result;
         }
-        return result;
-    }
+    };
 };
+export const streetNameMatcher = nameMatcherFactory(streetNamePattern);
 const MainSeparator = createToken({ name: "MainSeparator", pattern: / - / });
 const From = createToken({ name: "From", pattern: /od/ });
 const To = createToken({ name: "To", pattern: /do/ });
@@ -93,9 +101,13 @@ const Without = createToken({
     name: "Without",
     pattern: /bez|vyjma|mimo|s výjimkou|kromě/,
 });
+const MunicipalityPartName = createToken({
+    name: "MunicipalityPartName",
+    pattern: nameMatcherFactory(municipalityPartNamePattern),
+});
 const StreetName = createToken({
     name: "StreetName",
-    pattern: streetNameMatcher,
+    pattern: nameMatcherFactory(streetNamePattern),
 });
 const Number = createToken({
     name: "Number",
@@ -131,6 +143,7 @@ const smdTokens = [
     Slash,
     Space,
     // Colon,
+    MunicipalityPartName,
     StreetName,
 ];
 MainSeparator.LABEL = "' - '";
@@ -151,4 +164,4 @@ const tokenVocabulary = {};
 smdTokens.forEach((tokenType) => {
     tokenVocabulary[tokenType.name] = tokenType;
 });
-export { MainSeparator, Separator, OddType, EvenType, DescriptiveType, AllType, Number, From, To, AndAbove, AndBelow, Without, Hyphen, Slash, Space, StreetName, smdTokens, tokenVocabulary, };
+export { MainSeparator, Separator, OddType, EvenType, DescriptiveType, AllType, Number, From, To, AndAbove, AndBelow, Without, Hyphen, Slash, Space, StreetName, MunicipalityPartName, smdTokens, tokenVocabulary, };

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

@@ -4,10 +4,16 @@ export interface ProcessedSmdLines {
     smdLines: SmdLine[];
     errors: SmdError[];
 }
-export interface SmdLine {
+export type SmdLineType = "street" | "wholeMunicipalityLine" | "municipalitySwitch" | "municipalityPart";
+export type SmdLine = {
+    type: "street";
     street: string;
     numberSpec: SeriesSpec[] | NegativeSeriesSpec;
-}
+} | {
+    type: "municipalityPart";
+    municipalityPart: string;
+    numberSpec: SeriesSpec[] | NegativeSeriesSpec;
+};
 export interface SeriesSpec {
     type: SeriesType;
     ranges: (RangeSpec | FullStreetNumber)[];
@@ -74,7 +80,14 @@ export interface SmdState {
     currentMunicipality: MunicipalityWithFounder;
     currentFilterMunicipality: DbMunicipality;
     currentSchool: School;
-    noStreetNameSchoolIzo: string;
+    rests: {
+        noStreetNameSchoolIzo: string;
+        municipalityParts: {
+            municipalityPartCode: number;
+            schoolIzo: string;
+        }[];
+        wholeMunicipalitySchoolIzo: string;
+    };
     municipalities: Municipality[];
 }
 export interface ProcessLineCallbackParams {

package/package.json

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