text-to-map 1.1.19 → 1.1.20

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

@@ -0,0 +1,4 @@
+import { Municipality } from "./types";
+import { FeatureCollection, MultiPolygon, Polygon } from "@turf/helpers";
+export declare const municipalityToPolygons: (municipality: Municipality) => Promise<FeatureCollection>;
+export declare const createPolygons: (municipality: Municipality, cityPolygons: FeatureCollection<Polygon | MultiPolygon>[]) => FeatureCollection;

package/dist/street-markdown/polygons.js

@@ -0,0 +1,95 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Delaunay } from "d3-delaunay";
+import { featureCollection, } from "@turf/helpers";
+import intersect from "@turf/intersect";
+import { toMercator, toWgs84 } from "@turf/projection";
+import union from "@turf/union";
+import { getCityPolygonGeojsons } from "../db/cities";
+export const municipalityToPolygons = (municipality) => __awaiter(void 0, void 0, void 0, function* () {
+    const cityPolygons = yield getCityPolygonGeojsons(municipality.cityCodes);
+    return createPolygons(municipality, Object.values(cityPolygons));
+});
+export const createPolygons = (municipality, cityPolygons) => {
+    const citiesMultipolygon = createCitiesMultipolygon(cityPolygons);
+    const uniquePoints = new Map();
+    for (const school of municipality.schools) {
+        for (const point of school.addresses) {
+            if (!uniquePoints.has(point.address)) {
+                uniquePoints.set(point.address, {
+                    type: "Feature",
+                    geometry: {
+                        type: "Point",
+                        coordinates: [point.lng, point.lat],
+                    },
+                    properties: {
+                        schools: [school.izo],
+                    },
+                });
+            }
+            else {
+                uniquePoints.get(point.address).properties.schools.push(school.izo);
+            }
+        }
+    }
+    const points = {
+        type: "FeatureCollection",
+        features: Array.from(uniquePoints.values()),
+    };
+    const polygons = d3DelaunayVoronoi(points);
+    const unitedPolygons = [];
+    let colorIndex = 0;
+    for (const school of municipality.schools) {
+        const schoolPolygons = polygons.features.filter((polygon) => polygon.properties.schools.includes(school.izo));
+        const schoolPolygon = intersect(schoolPolygons.length > 1
+            ? union(featureCollection(schoolPolygons))
+            : schoolPolygons[0], citiesMultipolygon);
+        unitedPolygons.push(Object.assign(Object.assign({}, schoolPolygon), { properties: {
+                schoolIzo: school.izo,
+                colorIndex,
+            } }));
+        colorIndex++;
+    }
+    const { type } = polygons;
+    return {
+        type,
+        features: [...unitedPolygons],
+    };
+};
+const d3DelaunayVoronoi = (points) => {
+    const converted = points.features.map((p) => toMercator([p.geometry.coordinates[0], p.geometry.coordinates[1]]));
+    const bbox = [...toMercator([-180, -85]), ...toMercator([180, 85])];
+    const delaunay = new Delaunay(Float64Array.of(...converted.flat()));
+    const voronoi = delaunay.voronoi(bbox);
+    return {
+        type: "FeatureCollection",
+        features: Array.from(voronoi.cellPolygons()).map((polygon, i) => ({
+            type: "Feature",
+            geometry: {
+                type: "Polygon",
+                coordinates: [polygon.map((p) => toWgs84(p))],
+            },
+            properties: {
+                schools: points.features[i].properties.schools,
+                index: i,
+                neighbors: new Set(voronoi.neighbors(polygon.index)),
+            },
+        })),
+    };
+};
+const createCitiesMultipolygon = (cityPolygons) => {
+    const cityPolygonFeatures = cityPolygons.reduce((acc, cityPolygon) => {
+        acc.push(...cityPolygon.features.filter((f) => f.geometry.type === "Polygon" || f.geometry.type === "MultiPolygon"));
+        return acc;
+    }, []);
+    return cityPolygonFeatures.length > 1
+        ? union(featureCollection(cityPolygonFeatures))
+        : cityPolygonFeatures[0];
+};

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

@@ -1,5 +1,5 @@
 import { Founder } from "../db/types";
-import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, MunicipalityWithFounderResult, ProcessLineCallbackParams, School, SmdError, SmdState } from "./types";
+import { ErrorCallbackParams, IntermediateMunicipality, IntermediateSchool, Municipality, IntermediateMunicipalityResult, ProcessLineCallbackParams, SmdError, SmdState } from "./types";
 interface ParseOrdinanceProps {
     lines: string[];
     initialState?: Partial<SmdState>;
@@ -9,9 +9,9 @@ interface ParseOrdinanceProps {
     includeUnmappedAddressPoints: boolean;
 }
 export declare const parseOrdinanceToAddressPoints: ({ lines, initialState, onError, onWarning, onProcessedLine, includeUnmappedAddressPoints, }: ParseOrdinanceProps) => Promise<Municipality[]>;
-export declare const convertMunicipality: (municipality: MunicipalityWithFounder) => Municipality;
-export declare const getNewMunicipalityByName: (name: string) => Promise<MunicipalityWithFounderResult>;
-export declare const getNewMunicipalityByFounderId: (founderId: number) => Promise<MunicipalityWithFounderResult>;
-export declare const getNewSchool: (name: string, founder: Founder | null, lineNumber: number, onError: (params: ErrorCallbackParams) => void) => Promise<School>;
+export declare const convertMunicipality: (municipality: IntermediateMunicipality) => Municipality;
+export declare const getNewMunicipalityByName: (name: string) => Promise<IntermediateMunicipalityResult>;
+export declare const getNewMunicipalityByFounderId: (founderId: number) => Promise<IntermediateMunicipalityResult>;
+export declare const getNewSchool: (name: string, founder: Founder | null, lineNumber: number, onError: (params: ErrorCallbackParams) => void) => Promise<IntermediateSchool>;
 export declare const wholeLineError: (message: string, line: string) => SmdError;
 export {};

package/dist/street-markdown/smd.js

@@ -11,18 +11,23 @@ import { checkStreetExists, findAddressPoints, getAddressPointById, } from "../d
 import { disconnectKnex } from "../db/db";
 import { findFounder, getFounderById } from "../db/founders";
 import { findSchool } from "../db/schools";
-import { founderToMunicipality } from "../db/types";
+import { MunicipalityType, founderToMunicipality } from "../db/types";
 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 = () => { }, includeUnmappedAddressPoints = false, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const state = Object.assign({ currentMunicipality: null, currentFilterMunicipality: null, currentSchool: null, rests: {
-                noStreetNameSchoolIzo: null,
+                noStreetNameSchool: {
+                    izo: null,
+                    lineNumber: null,
+                },
                 municipalityParts: [],
-                wholeMunicipalitySchoolIzo: null,
+                wholeMunicipalitySchool: {
+                    izo: null,
+                    lineNumber: null,
+                },
                 includeUnmappedAddressPoints,
-            }, municipalities: [] }, initialState);
+            }, cityCodes: [], municipalities: [] }, initialState);
         let lineNumber = 1;
         for (const rawLine of lines) {
             const line = cleanLine(rawLine);
@@ -51,22 +56,26 @@ export const parseOrdinanceToAddressPoints = ({ lines, initialState = {}, onErro
     finally {
         yield disconnectKnex();
     }
+    return [];
 });
-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,
+        schools: municipality.schools.map((school) => {
+            return {
+                name: school.name,
+                izo: school.izo,
+                addresses: Array.from(school.addressMap.values()),
+                position: school.position,
+            };
+        }),
+        cityCodes: [...new Set(municipality.cityCodes)],
+        districtCodes: [...new Set(municipality.districtCodes)],
         unmappedPoints: municipality.unmappedPoints,
     };
 };
 const processOneLine = (params) => __awaiter(void 0, void 0, void 0, function* () {
-    const { line, state } = params;
+    const { line, lineNumber, state } = params;
     if (line[0] === "#") {
         yield processMunicipalityLine(params);
         return;
@@ -90,20 +99,27 @@ const processOneLine = (params) => __awaiter(void 0, void 0, void 0, function* (
         yield processWholeMunicipalityLine(params);
     }
     else if (isRestWithNoStreetNameLine(line)) {
-        state.rests.noStreetNameSchoolIzo = state.currentSchool.izo;
+        state.rests.noStreetNameSchool = {
+            izo: state.currentSchool.izo,
+            lineNumber,
+        };
     }
     else if (isRestOfMunicipalityLine(line)) {
-        state.rests.wholeMunicipalitySchoolIzo = state.currentSchool.izo;
+        state.rests.wholeMunicipalitySchool = {
+            izo: state.currentSchool.izo,
+            lineNumber,
+        };
     }
     else if (isRestOfMunicipalityPartLine(line)) {
         const { municipalityPartCode, errors } = yield getRestOfMunicipalityPart(line, state.currentMunicipality.founder);
         if (errors.length > 0) {
-            params.onError({ lineNumber: params.lineNumber, line, errors });
+            params.onError({ lineNumber: lineNumber, line, errors });
         }
         else {
             state.rests.municipalityParts.push({
                 municipalityPartCode,
                 schoolIzo: state.currentSchool.izo,
+                lineNumber: lineNumber,
             });
         }
     }
@@ -157,6 +173,12 @@ const processMunicipalitySwitchLine = ({ line, state, lineNumber, onError, }) =>
         onError({ lineNumber, line, errors });
     }
     else {
+        if (municipality.type === MunicipalityType.City) {
+            state.currentMunicipality.cityCodes.push(municipality.code);
+        }
+        else {
+            state.currentMunicipality.districtCodes.push(municipality.code);
+        }
         state.currentFilterMunicipality = municipality;
     }
 });
@@ -166,13 +188,29 @@ const processWholeMunicipalityLine = ({ line, state, lineNumber, onError, }) =>
         onError({ lineNumber, line, errors });
     }
     else {
+        if (municipality.type === MunicipalityType.City) {
+            state.currentMunicipality.cityCodes.push(municipality.code);
+        }
+        else {
+            state.currentMunicipality.districtCodes.push(municipality.code);
+        }
         const addressPoints = yield findAddressPoints({
             type: "wholeMunicipality",
             municipality,
         });
-        state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+        addAddressPointsToSchool(state.currentSchool, addressPoints, lineNumber);
     }
 });
+const addAddressPointsToSchool = (school, addressPoints, lineNumber) => {
+    for (const point of addressPoints) {
+        if (school.addressMap.has(point.id)) {
+            school.addressMap.get(point.id).lineNumbers.push(lineNumber - 1);
+        }
+        else {
+            school.addressMap.set(point.id, mapAddressPointForExport(point, lineNumber));
+        }
+    }
+};
 const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { smdLines, errors } = parseLine(line);
     if (errors.length > 0) {
@@ -191,7 +229,7 @@ const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning,
                         smdLine,
                         municipality: state.currentFilterMunicipality,
                     });
-                    state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+                    addAddressPointsToSchool(state.currentSchool, addressPoints, lineNumber);
                 }
             }
             else if (smdLine.type === "municipalityPart") {
@@ -206,38 +244,38 @@ const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning,
                         municipality: state.currentFilterMunicipality,
                         municipalityPartCode,
                     });
-                    state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+                    addAddressPointsToSchool(state.currentSchool, addressPoints, lineNumber);
                 }
             }
         }
     }
 });
-const addRestToSchool = (restPoints, schoolIzo, state) => {
-    const addressPoints = state.currentMunicipality.schools.flatMap((school) => school.addresses);
+const addRestToSchool = (restPoints, schoolIzo, lineNumber, state) => {
+    const addressPointsIds = getAllAddressPointsIds(state.currentMunicipality);
     // filter out address points already present
-    const remainingPoints = restPoints.filter((point) => !addressPoints.some((ap) => ap.address === point.address));
+    const remainingPoints = restPoints.filter((point) => !addressPointsIds.has(point.id));
     // 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);
+    addAddressPointsToSchool(state.currentMunicipality.schools[schoolIndex], remainingPoints, lineNumber);
 };
 const addRests = (state) => __awaiter(void 0, void 0, void 0, function* () {
-    if (state.rests.noStreetNameSchoolIzo) {
-        yield addRestWithNoStreetNameToSchool(state);
+    if (state.rests.noStreetNameSchool.izo) {
+        yield addRestWithNoStreetNameToSchool(state.rests.noStreetNameSchool.lineNumber, state);
     }
-    if (state.rests.wholeMunicipalitySchoolIzo) {
-        yield addRestOfMunicipality(state);
+    if (state.rests.wholeMunicipalitySchool.izo) {
+        yield addRestOfMunicipality(state.rests.wholeMunicipalitySchool.lineNumber, state);
     }
     for (const rest of state.rests.municipalityParts) {
-        yield addRestOfMunicipalityPart(state, rest.municipalityPartCode, rest.schoolIzo);
+        yield addRestOfMunicipalityPart(state, rest.municipalityPartCode, rest.schoolIzo, rest.lineNumber);
     }
     if (state.rests.includeUnmappedAddressPoints) {
         yield addRestOfMunicipalityToUnmappedPoints(state);
     }
-    state.rests.noStreetNameSchoolIzo = null;
-    state.rests.wholeMunicipalitySchoolIzo = null;
+    state.rests.noStreetNameSchool.izo = null;
+    state.rests.wholeMunicipalitySchool.izo = null;
     state.rests.municipalityParts = [];
 });
-const addRestWithNoStreetNameToSchool = (state) => __awaiter(void 0, void 0, void 0, function* () {
+const addRestWithNoStreetNameToSchool = (lineNumber, state) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points without street name for current municipality
     const pointsNoStreetName = yield findAddressPoints({
         type: "wholeMunicipalityNoStreetName",
@@ -246,31 +284,34 @@ const addRestWithNoStreetNameToSchool = (state) => __awaiter(void 0, void 0, voi
             type: state.currentMunicipality.founder.municipalityType,
         },
     });
-    addRestToSchool(pointsNoStreetName, state.rests.noStreetNameSchoolIzo, state);
+    addRestToSchool(pointsNoStreetName, state.rests.noStreetNameSchool.izo, lineNumber, state);
 });
-const addRestOfMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
-    addRestToSchool(yield getRestOfMunicipality(state), state.rests.wholeMunicipalitySchoolIzo, state);
+const addRestOfMunicipality = (lineNumber, state) => __awaiter(void 0, void 0, void 0, function* () {
+    addRestToSchool(yield getRestOfMunicipality(state), state.rests.wholeMunicipalitySchool.izo, lineNumber, state);
 });
 const addRestOfMunicipalityToUnmappedPoints = (state) => __awaiter(void 0, void 0, void 0, function* () {
     state.currentMunicipality.unmappedPoints = (yield getRestOfMunicipality(state)).map(mapAddressPointForExport);
 });
 const getRestOfMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points for current municipality
-    return yield findAddressPoints({
+    const allPoints = yield findAddressPoints({
         type: "wholeMunicipality",
         municipality: {
             code: state.currentMunicipality.founder.cityOrDistrictCode,
             type: state.currentMunicipality.founder.municipalityType,
         },
     });
+    // filter out address points already present
+    const addressPointsIds = getAllAddressPointsIds(state.currentMunicipality);
+    return allPoints.filter((point) => !addressPointsIds.has(point.id));
 });
-const addRestOfMunicipalityPart = (state, municipalityPartCode, schoolIzo) => __awaiter(void 0, void 0, void 0, function* () {
+const addRestOfMunicipalityPart = (state, municipalityPartCode, schoolIzo, lineNumber) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points for current municipality
     const allPoints = yield findAddressPoints({
         type: "wholeMunicipalityPart",
         municipalityPartCode,
     });
-    addRestToSchool(allPoints, schoolIzo, state);
+    addRestToSchool(allPoints, schoolIzo, lineNumber, state);
 });
 export const getNewMunicipalityByName = (name) => __awaiter(void 0, void 0, void 0, function* () {
     const { founder, errors } = yield findFounder(name);
@@ -285,6 +326,12 @@ const getNewMunicipality = (founder, errors) => ({
         municipalityName: founder ? founder.name : "Neznámá obec",
         founder,
         schools: [],
+        cityCodes: founder.municipalityType === MunicipalityType.City
+            ? [founder.cityOrDistrictCode]
+            : [],
+        districtCodes: founder.municipalityType === MunicipalityType.District
+            ? [founder.cityOrDistrictCode]
+            : [],
         unmappedPoints: [],
     },
     errors,
@@ -311,21 +358,21 @@ export const getNewSchool = (name, founder, lineNumber, onError) => __awaiter(vo
             }
         }
     }
-    return exportSchool;
+    return Object.assign(Object.assign({}, exportSchool), { addressMap: new Map() });
 });
-const mapAddressPointForExport = (addressPoint) => {
-    return {
-        address: addressPoint.address,
-        lat: addressPoint.lat,
-        lng: addressPoint.lng,
-    };
+const getAllAddressPointsIds = (municipality) => {
+    const addressPointsIds = new Set();
+    for (const school of municipality.schools) {
+        for (const id of school.addressMap.keys()) {
+            addressPointsIds.add(id);
+        }
+    }
+    return addressPointsIds;
 };
-const mapSchoolForExport = (school) => ({
-    name: school.name,
-    izo: school.izo,
-    addresses: school.addresses,
-    position: school.position ? mapAddressPointForExport(school.position) : null,
-});
+const mapAddressPointForExport = (addressPoint, lineNumber) => {
+    return Object.assign({ address: addressPoint.address, lat: addressPoint.lat, lng: addressPoint.lng }, (lineNumber ? { lineNumbers: [lineNumber - 1] } : {}));
+};
+const mapSchoolForExport = (school) => (Object.assign(Object.assign({}, school), { position: school.position ? mapAddressPointForExport(school.position) : null }));
 const cleanLine = (line) => {
     return line.trim().replace(/–/g, "-");
 };

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

@@ -53,6 +53,7 @@ export interface ExportAddressPoint {
     address: string;
     lat: number;
     lng: number;
+    lineNumbers?: number[];
 }
 export declare const isAddressPoint: (something: AddressPoint | ExportAddressPoint) => something is AddressPoint;
 export interface School {
@@ -61,8 +62,13 @@ export interface School {
     position?: AddressPoint | ExportAddressPoint;
     addresses: ExportAddressPoint[];
 }
+export interface IntermediateSchool extends School {
+    addressMap: Map<number, ExportAddressPoint>;
+}
 export interface Municipality {
     municipalityName: string;
+    cityCodes: number[];
+    districtCodes: number[];
     schools: School[];
     unmappedPoints: ExportAddressPoint[];
 }
@@ -77,23 +83,34 @@ export interface MunicipalityPartResult {
 export interface MunicipalityWithFounder extends Municipality {
     founder: Founder | null;
 }
-export interface MunicipalityWithFounderResult {
-    municipality: MunicipalityWithFounder;
+export interface IntermediateMunicipality extends MunicipalityWithFounder {
+    schools: IntermediateSchool[];
+}
+export interface IntermediateMunicipalityResult {
+    municipality: IntermediateMunicipality;
     errors: SmdError[];
 }
 export interface SmdState {
-    currentMunicipality: MunicipalityWithFounder;
+    currentMunicipality: IntermediateMunicipality;
     currentFilterMunicipality: DbMunicipality;
-    currentSchool: School;
+    currentSchool: IntermediateSchool;
     rests: {
-        noStreetNameSchoolIzo: string;
+        noStreetNameSchool: {
+            izo: string;
+            lineNumber: number;
+        };
         municipalityParts: {
             municipalityPartCode: number;
             schoolIzo: string;
+            lineNumber: number;
         }[];
-        wholeMunicipalitySchoolIzo: string;
+        wholeMunicipalitySchool: {
+            izo: string;
+            lineNumber: number;
+        };
         includeUnmappedAddressPoints: boolean;
     };
+    cityCodes: number[];
     municipalities: Municipality[];
 }
 export interface ProcessLineCallbackParams {

package/dist/utils/helpers.d.ts

@@ -10,6 +10,7 @@ export interface OpenDataSyncOptions {
     streetsAtomUrl: string;
     streetZipFolderName: string;
     streetDbfFileName: string;
+    polygonShpFileName: string;
     schoolsXmlUrl: string;
     schoolsXmlFileName: string;
     regionsCsvUrl: string;

package/dist/utils/helpers.js

@@ -31,6 +31,7 @@ export const prepareOptions = (options) => {
         streetsAtomUrl: "https://atom.cuzk.cz/RUIAN-OBCE-SHP/RUIAN-OBCE-SHP.xml",
         streetZipFolderName: "streets",
         streetDbfFileName: "UL_L.dbf",
+        polygonShpFileName: "OBEC_P.shp",
         schoolsXmlUrl: "https://rejstriky.msmt.cz/opendata/vrejcelk.xml",
         schoolsXmlFileName: "school-register.xml",
         regionsCsvUrl: "https://www.czso.cz/documents/10180/23208674/struktura_uzemi_cr.csv",

package/dist/utils/jtsk2wgs84.js

@@ -73,8 +73,12 @@ export default function jtsk2wgs84(x, y, h = 200) {
     return {
         jtsk_x: originalX,
         jtsk_y: originalY,
-        lat: (B / Math.PI) * 180,
-        lon: (L / Math.PI) * 180,
+        lat: roundToNDecimalPlaces((B / Math.PI) * 180, 6),
+        lon: roundToNDecimalPlaces((L / Math.PI) * 180, 6),
         altitude: Math.round(h * 100) / 100,
     };
 }
+function roundToNDecimalPlaces(toRound, decimalPlaces) {
+    return (Math.round(toRound * Math.pow(10, decimalPlaces)) /
+        Math.pow(10, decimalPlaces));
+}

package/package.json

@@ -2,13 +2,21 @@
   "type": "module",
   "dependencies": {
     "@turf/distance": "^6.5.0",
+    "@turf/helpers": "^6.5.0",
+    "@turf/intersect": "^6.5.0",
+    "@turf/meta": "^7.0.0-alpha.110",
+    "@turf/projection": "^7.0.0-alpha.2",
+    "@turf/union": "^7.0.0-alpha.113",
     "adm-zip": "^0.5.9",
     "better-sqlite3": "^8.0.1",
     "chevrotain": "^10.4.2",
     "csv-parse": "^5.3.3",
     "czech-address": "^1.0.1",
+    "d3-delaunay": "^6.0.4",
     "dotenv": "^16.3.1",
     "feedparser": "^2.2.10",
+    "geojson": "^0.5.0",
+    "graphlib": "^2.1.8",
     "iconv-lite": "^0.6.3",
     "knex": "^2.4.2",
     "lodash": "^4.17.21",
@@ -17,6 +25,7 @@
     "parsedbf": "^1.1.1",
     "pg": "^8.11.1",
     "sax": "^1.2.4",
+    "shp-to-geojson": "^1.0.0",
     "typescript": "^4.9.4"
   },
   "devDependencies": {
@@ -24,6 +33,7 @@
     "@jest/globals": "^29.5.0",
     "@types/adm-zip": "^0.5.0",
     "@types/better-sqlite3": "^7.6.3",
+    "@types/d3-delaunay": "^6.0.4",
     "@types/feedparser": "^2.2.5",
     "@types/lodash": "^4.14.196",
     "@types/node": "^18.11.17",
@@ -39,6 +49,7 @@
     "address-points": "ts-node --experimental-specifier-resolution=node --esm src/bin/address-points.ts",
     "regions": "ts-node --experimental-specifier-resolution=node --esm src/bin/regions.ts",
     "cities": "ts-node --experimental-specifier-resolution=node --esm src/bin/cities.ts",
+    "polygons": "ts-node --experimental-specifier-resolution=node --esm src/bin/polygons.ts",
     "schools": "ts-node --experimental-specifier-resolution=node --esm src/bin/schools.ts",
     "streets": "ts-node --experimental-specifier-resolution=node --esm src/bin/streets.ts",
     "diagrams": "ts-node --experimental-specifier-resolution=node --esm src/bin/generate-syntax-diagrams.ts",
@@ -57,7 +68,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.19",
+  "version": "1.1.20",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [