text-to-map 1.0.5 → 1.0.7

package/dist/bin/address-points.js

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

package/dist/bin/clear-all.js

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

package/dist/bin/constants.d.ts

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

package/dist/bin/constants.js

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

package/dist/bin/parse-ordinance.js

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

package/dist/bin/regions.js

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

package/dist/bin/schools.js

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

package/dist/bin/streets.js

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

package/dist/bin/sync-all.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin/sync-all.js

@@ -0,0 +1,3 @@
+import { downloadAndImportEverything } from "../index";
+import { defaultBinOptions } from "./constants";
+downloadAndImportEverything(defaultBinOptions);

package/dist/db/founders.js

@@ -61,11 +61,12 @@ export const insertFounders = (founders) => {
         }
         const founderId = insertAutoincrementRow([
             sanitizeMunicipalityName(founder.name),
+            sanitizeMunicipalityName(extractedMunicipalityName),
             founder.ico,
             String(founder.originalType),
             cityCode,
             cityDistrictCode,
-        ], "founder", ["name", "ico", "founder_type_code", "city_code", "city_district_code"]);
+        ], "founder", ["name", "short_name", "ico", "founder_type_code", "city_code", "city_district_code"]);
         // founder table has unique (name, ico) with on conflict ignore, so possibly
         // the row has not been inserted
         if (founderId !== null) {

package/dist/db/regions.d.ts

@@ -1,4 +1,4 @@
-export declare const Column: {
+interface RegionsColumn {
     cityName: number;
     cityCode: number;
     cityType: number;
@@ -15,9 +15,17 @@ export declare const Column: {
     regionCsuCode100: number;
     regionCsuCode108Nuts: number;
     regionRuianCode: number;
-};
-export declare const insertRegionsAndOrps: (data: string[][]) => number;
-export declare const insertRegions: (buffer: string[][]) => number;
-export declare const insertCounties: (buffer: string[][]) => number;
-export declare const insertOrps: (buffer: string[][]) => number;
-export declare const insertCities: (buffer: string[][]) => number;
+}
+export interface RegionsTableSchema {
+    tableSchema: {
+        columns: {
+            name: string;
+        }[];
+    };
+}
+export declare const insertRegionsAndOrps: (data: string[][], schema: RegionsTableSchema) => number;
+export declare const insertRegions: (buffer: string[][], columnIndex: RegionsColumn) => number;
+export declare const insertCounties: (buffer: string[][], columnIndex: RegionsColumn) => number;
+export declare const insertOrps: (buffer: string[][], columnIndex: RegionsColumn) => number;
+export declare const insertCities: (buffer: string[][], columnIndex: RegionsColumn) => number;
+export {};

package/dist/db/regions.js

@@ -1,30 +1,13 @@
 import { extractKeyValuesPairs, getDb, insertMultipleRows } from "./db";
-export const Column = {
-    cityName: 0,
-    cityCode: 1,
-    cityType: 2,
-    orpName: 9,
-    orpCsuCode65: 10,
-    orpRuianCode: 11,
-    orpCityCode: 12,
-    countyName: 13,
-    countyCsuCode101Lau: 14,
-    countyCsuCode109Nuts: 15,
-    countyRuianCode: 16,
-    regionName: 17,
-    regionShortName: 18,
-    regionCsuCode100: 19,
-    regionCsuCode108Nuts: 20,
-    regionRuianCode: 21,
-};
-export const insertRegionsAndOrps = (data) => {
+export const insertRegionsAndOrps = (data, schema) => {
+    const columnIndex = getColumnIndexFromSchema(schema);
     let changes = 0;
-    changes += insertRegions(data);
-    changes += insertCounties(data);
-    changes += insertOrps(data);
+    changes += insertRegions(data, columnIndex);
+    changes += insertCounties(data, columnIndex);
+    changes += insertOrps(data, columnIndex);
     // cities are most likely already inserted, but in case they're not,
     // we need to insert them before updating them with region data
-    changes += insertCities(data);
+    changes += insertCities(data, columnIndex);
     const db = getDb();
     const updateStatement = db.prepare(`UPDATE city SET
       region_code = ?,
@@ -32,34 +15,63 @@ export const insertRegionsAndOrps = (data) => {
       orp_code = ?
     WHERE code = ?`);
     data.forEach((data) => {
-        changes += updateStatement.run(data[Column.regionRuianCode], data[Column.countyRuianCode], data[Column.orpRuianCode], data[Column.cityCode]).changes;
+        changes += updateStatement.run(data[columnIndex.regionRuianCode], data[columnIndex.countyRuianCode], data[columnIndex.orpRuianCode], data[columnIndex.cityCode]).changes;
     });
     return changes;
 };
-export const insertRegions = (buffer) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.regionRuianCode, [
-        Column.regionName,
-        Column.regionShortName,
-        Column.regionCsuCode100,
-        Column.regionCsuCode108Nuts,
+export const insertRegions = (buffer, columnIndex) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.regionRuianCode, [
+        columnIndex.regionName,
+        columnIndex.regionShortName,
+        columnIndex.regionCsuCode100,
+        columnIndex.regionCsuCode108Nuts,
     ]), "region", ["code", "name", "short_name", "csu_code_100", "csu_code_108_nuts"]);
 };
-export const insertCounties = (buffer) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.countyRuianCode, [
-        Column.countyName,
-        Column.countyCsuCode101Lau,
-        Column.countyCsuCode109Nuts,
-        Column.regionRuianCode,
+export const insertCounties = (buffer, columnIndex) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.countyRuianCode, [
+        columnIndex.countyName,
+        columnIndex.countyCsuCode101Lau,
+        columnIndex.countyCsuCode109Nuts,
+        columnIndex.regionRuianCode,
     ]), "county", ["code", "name", "csu_code_101_lau", "csu_code_109_nuts", "region_code"]);
 };
-export const insertOrps = (buffer) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.orpRuianCode, [
-        Column.orpName,
-        Column.orpCsuCode65,
-        Column.regionRuianCode,
-        Column.countyRuianCode,
+export const insertOrps = (buffer, columnIndex) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.orpRuianCode, [
+        columnIndex.orpName,
+        columnIndex.orpCsuCode65,
+        columnIndex.regionRuianCode,
+        columnIndex.countyRuianCode,
     ]), "orp", ["code", "name", "csu_code_65", "region_code", "county_code"]);
 };
-export const insertCities = (buffer) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.cityCode, [Column.cityName]), "city", ["code", "name"]);
+export const insertCities = (buffer, columnIndex) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.cityCode, [columnIndex.cityName]), "city", ["code", "name"]);
+};
+const getColumnIndexFromSchema = (schema) => {
+    const names = schema.tableSchema.columns.map((column) => column.name);
+    const columnIndex = {
+        cityName: findOrDie(names, "obec_text"),
+        cityCode: findOrDie(names, "obec_kod"),
+        cityType: findOrDie(names, "obec_typ"),
+        orpName: findOrDie(names, "orp_text"),
+        orpCsuCode65: findOrDie(names, "orp_csu_cis65_kod"),
+        orpRuianCode: findOrDie(names, "orp_ruian_kod"),
+        orpCityCode: findOrDie(names, "orp_sidlo_obec_kod"),
+        countyName: findOrDie(names, "okres_text"),
+        countyCsuCode101Lau: findOrDie(names, "okres_csu_cis101_lau_kod"),
+        countyCsuCode109Nuts: findOrDie(names, "okres_csu_cis109_nuts_kod"),
+        countyRuianCode: findOrDie(names, "okres_ruian_kod"),
+        regionName: findOrDie(names, "kraj_text"),
+        regionShortName: findOrDie(names, "kraj_zkratka"),
+        regionCsuCode100: findOrDie(names, "kraj_csu_cis100_kod"),
+        regionCsuCode108Nuts: findOrDie(names, "kraj_csu_cis108_nuts_kod"),
+        regionRuianCode: findOrDie(names, "kraj_ruian_vusc_kod"),
+    };
+    return columnIndex;
+};
+const findOrDie = (columnNames, name) => {
+    const index = columnNames.indexOf(name);
+    if (index < 0) {
+        throw new Error(`Column '${name}' not found in region schema. Check https://data.gov.cz/datov%C3%A1-sada?iri=https%3A%2F%2Fdata.gov.cz%2Fzdroj%2Fdatov%C3%A9-sady%2F00025593%2F271b0fb7c2abb7f44e12ad57617821b2 for current dataset info or search for 'Struktura území ČR se všemi kódy území od obcí po stát dle číselníků ČSÚ, klasifikace NUTS a kódů RÚIAN.'.`);
+    }
+    return index;
 };

package/dist/index.d.ts

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

package/dist/index.js

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

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

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

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

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

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

@@ -25,9 +25,15 @@ const downloadAndImportDataToDb = (options) => __awaiter(void 0, void 0, void 0,
         rows.push(data);
     });
     yield pipeline(response.body, iconv.decodeStream("utf-8"), parseStream);
+    const schemaResponse = yield fetch(options.regionsSchemaUrl);
+    if (schemaResponse.status !== 200) {
+        throw new Error(`The file could not be downloaded. HTTP Code: ${schemaResponse.status}`);
+    }
+    // @ts-ignore
+    const schema = yield schemaResponse.json();
     console.log("Parsing completed. Starting to import data to DB...");
     initDb(options);
-    insertRegionsAndOrps(rows);
+    insertRegionsAndOrps(rows, schema);
     console.log(`Import completed. Total imported rows: ${rows.length}`);
 });
 export const downloadAndImportRegions = (options = {}) => __awaiter(void 0, void 0, void 0, function* () {

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

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

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

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

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

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

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

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

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

@@ -1,9 +1,7 @@
 import { Founder } from "../db/types";
-import { OpenDataSyncOptions } from "../utils/helpers";
-import { Municipality } from "./types";
-interface MunicipalityWithFounder extends Municipality {
-    founder: Founder | null;
-}
-export declare const parseOrdinanceToAddressPoints: (lines: string[], options?: OpenDataSyncOptions) => Municipality[];
+import { OpenDataSyncOptionsPartial } from "../utils/helpers";
+import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, ProcessLineCallbackParams, School, SmdState } from "./types";
+export declare const parseOrdinanceToAddressPoints: (lines: string[], options?: OpenDataSyncOptionsPartial, initialState?: Partial<SmdState>, onError?: (params: ErrorCallbackParams) => void, onWarning?: (params: ErrorCallbackParams) => void, onProcessedLine?: (params: ProcessLineCallbackParams) => void) => Municipality[];
 export declare const convertMunicipality: (municipality: MunicipalityWithFounder) => Municipality;
-export {};
+export declare const getNewMunicipality: (name: string, options?: OpenDataSyncOptionsPartial) => MunicipalityWithFounder;
+export declare const getNewSchool: (name: string, founder: Founder | null, options?: OpenDataSyncOptionsPartial) => School;

package/dist/street-markdown/smd.js

@@ -2,12 +2,152 @@ import { checkStreetExists, findAddressPoints, getAddressPointById, } from "../d
 import { setDbConfig } from "../db/db";
 import { findFounder } from "../db/founders";
 import { findSchool } from "../db/schools";
-import { founderToMunicipality, } from "../db/types";
+import { founderToMunicipality } from "../db/types";
 import { prepareOptions } from "../utils/helpers";
 import { getSwitchMunicipality, getWholeMunicipality, isMunicipalitySwitch, isWholeMunicipality, } from "./municipality";
 import { parseLine } from "./smd-line-parser";
 import { isAddressPoint, } from "./types";
-const getNewMunicipality = (name) => {
+export const parseOrdinanceToAddressPoints = (lines, options = {}, initialState = {}, onError = () => { }, onWarning = () => { }, onProcessedLine = () => { }) => {
+    const readyOptions = prepareOptions(options);
+    setDbConfig({
+        filePath: readyOptions.dbFilePath,
+        initFilePath: readyOptions.dbInitFilePath,
+    });
+    const state = Object.assign({ currentMunicipality: null, currentFilterMunicipality: null, currentSchool: null, municipalities: [] }, initialState);
+    let lineNumber = 1;
+    for (const rawLine of lines) {
+        const line = cleanLine(rawLine);
+        processOneLine({
+            line,
+            state,
+            lineNumber,
+            onError,
+            onWarning,
+        });
+        onProcessedLine({ lineNumber, line });
+        lineNumber++;
+    }
+    if (state.currentSchool != null) {
+        if (state.currentMunicipality == null) {
+            state.currentMunicipality = getNewMunicipality("");
+        }
+        state.currentMunicipality.schools.push(mapSchoolForExport(state.currentSchool));
+    }
+    if (state.currentMunicipality != null) {
+        state.municipalities.push(convertMunicipality(state.currentMunicipality));
+    }
+    return state.municipalities;
+};
+const filterOutSchoolAddressPoint = (addressPoints, school) => {
+    const schoolPosition = school.position;
+    return schoolPosition && isAddressPoint(schoolPosition)
+        ? (addressPoints = addressPoints.filter((ap) => ap.id !== schoolPosition.id))
+        : addressPoints;
+};
+export const convertMunicipality = (municipality) => {
+    return {
+        municipalityName: municipality.municipalityName,
+        schools: municipality.schools,
+    };
+};
+const processOneLine = (params) => {
+    const { line, state } = params;
+    if (line[0] === "#") {
+        processMunicipalityLine(params);
+        return;
+    }
+    if (line === "") {
+        // end of school
+        processEmptyLine(params);
+        return;
+    }
+    if (line[0] === "!") {
+        return;
+    }
+    if (state.currentSchool === null) {
+        processSchoolLine(params);
+        return;
+    }
+    if (isMunicipalitySwitch(line)) {
+        processMunicipalitySwitchLine(params);
+    }
+    else if (isWholeMunicipality(line)) {
+        processWholeMunicipalityLine(params);
+    }
+    else {
+        processAddressPointLine(params);
+    }
+};
+const processMunicipalityLine = ({ line, state }) => {
+    if (state.currentSchool !== null) {
+        state.currentMunicipality.schools.push(state.currentSchool);
+        state.currentSchool = null;
+    }
+    if (state.currentMunicipality !== null) {
+        state.municipalities.push(convertMunicipality(state.currentMunicipality));
+    }
+    state.currentMunicipality = getNewMunicipality(line.substring(1).trim());
+    state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
+    state.currentSchool = null;
+};
+const processEmptyLine = ({ state }) => {
+    if (state.currentSchool !== null) {
+        state.currentMunicipality.schools.push(state.currentSchool);
+        state.currentSchool = null;
+    }
+};
+const processSchoolLine = ({ line, lineNumber, state }) => {
+    if (state.currentMunicipality === null) {
+        throw new Error("No municipality defined on line " + lineNumber);
+    }
+    state.currentSchool = getNewSchool(line, state.currentMunicipality.founder);
+    state.currentFilterMunicipality = founderToMunicipality(state.currentMunicipality.founder);
+};
+const processMunicipalitySwitchLine = ({ line, state, lineNumber, onError, }) => {
+    const { municipality, errors } = getSwitchMunicipality(line);
+    if (errors.length > 0) {
+        onError({ lineNumber, line, errors });
+    }
+    else {
+        state.currentFilterMunicipality = municipality;
+    }
+};
+const processWholeMunicipalityLine = ({ line, state, lineNumber, onError, }) => {
+    const { municipality, errors } = getWholeMunicipality(line);
+    if (errors.length > 0) {
+        onError({ lineNumber, line, errors });
+    }
+    else {
+        const addressPoints = findAddressPoints({ wholeMunicipality: true, street: "", numberSpec: [] }, municipality);
+        state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+    }
+};
+const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning, }) => {
+    const { smdLines, errors } = parseLine(line);
+    if (errors.length > 0) {
+        onError({ lineNumber, line, errors });
+    }
+    else {
+        smdLines.forEach((smdLine) => {
+            const { exists, errors } = checkStreetExists(smdLine.street, state.currentMunicipality.founder);
+            if (errors.length > 0) {
+                onWarning({ lineNumber, line, errors });
+            }
+            if (exists) {
+                let addressPoints = findAddressPoints(smdLine, state.currentFilterMunicipality);
+                state.currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, state.currentSchool).map(mapAddressPointForExport));
+            }
+        });
+    }
+};
+export const getNewMunicipality = (name, options) => {
+    if (options) {
+        options = prepareOptions(options);
+        setDbConfig({
+            filePath: options.dbFilePath,
+            initFilePath: options.dbInitFilePath,
+        });
+    }
     const { founder, errors } = findFounder(name);
     if (errors.length > 0) {
         errors.forEach(console.error);
@@ -18,7 +158,14 @@ const getNewMunicipality = (name) => {
         schools: [],
     };
 };
-const getNewSchool = (name, founder) => {
+export const getNewSchool = (name, founder, options) => {
+    if (options) {
+        options = prepareOptions(options);
+        setDbConfig({
+            filePath: options.dbFilePath,
+            initFilePath: options.dbInitFilePath,
+        });
+    }
     let exportSchool = {
         name: name,
         izo: "",
@@ -54,129 +201,3 @@ const mapSchoolForExport = (school) => ({
 const cleanLine = (line) => {
     return line.trim().replace(/–/g, "-");
 };
-export const parseOrdinanceToAddressPoints = (lines, options = {}) => {
-    const readyOptions = prepareOptions(options);
-    setDbConfig({
-        filePath: readyOptions.dbFilePath,
-        initFilePath: readyOptions.dbInitFilePath,
-    });
-    let errorCount = 0;
-    const errorLines = [];
-    let warningCount = 0;
-    let lineNumber = 1;
-    let municipalities = [];
-    let currentMunicipality = null;
-    let currentFilterMunicipality = null;
-    let currentSchool = null;
-    const reportErrors = (line, errors) => {
-        errors.forEach(console.error);
-        console.error(`Invalid street definition on line ${lineNumber}: ${line}`);
-        errorCount++;
-        errorLines.push(`line ${lineNumber}: ${line}`);
-    };
-    lines.forEach((rawLine) => {
-        let line = cleanLine(rawLine);
-        if (line[0] === "#") {
-            // a new municipality
-            if (currentSchool !== null) {
-                currentMunicipality.schools.push(currentSchool);
-                currentSchool = null;
-            }
-            if (currentMunicipality !== null) {
-                municipalities.push(convertMunicipality(currentMunicipality));
-            }
-            currentMunicipality = getNewMunicipality(line.substring(1).trim());
-            currentFilterMunicipality = founderToMunicipality(currentMunicipality.founder);
-            currentSchool = null;
-        }
-        else if (line === "") {
-            // empty line (end of school)
-            if (currentSchool !== null) {
-                currentMunicipality.schools.push(currentSchool);
-                currentSchool = null;
-            }
-        }
-        else {
-            if (currentSchool === null) {
-                if (currentMunicipality === null) {
-                    throw new Error("No municipality defined on line " + lineNumber);
-                }
-                currentSchool = getNewSchool(line, currentMunicipality.founder);
-                currentFilterMunicipality = founderToMunicipality(currentMunicipality.founder);
-            }
-            else {
-                if (line[0] !== "!") {
-                    if (isMunicipalitySwitch(line)) {
-                        const { municipality, errors } = getSwitchMunicipality(line);
-                        if (errors.length > 0) {
-                            reportErrors(line, errors);
-                        }
-                        else {
-                            currentFilterMunicipality = municipality;
-                        }
-                    }
-                    else if (isWholeMunicipality(line)) {
-                        const { municipality, errors } = getWholeMunicipality(line);
-                        if (errors.length > 0) {
-                            reportErrors(line, errors);
-                        }
-                        else {
-                            const addressPoints = findAddressPoints({ wholeMunicipality: true, street: "", numberSpec: [] }, municipality);
-                            currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, currentSchool).map(mapAddressPointForExport));
-                        }
-                    }
-                    else {
-                        // address point
-                        const { smdLines, errors } = parseLine(line);
-                        if (errors.length > 0) {
-                            reportErrors(line, errors);
-                        }
-                        else {
-                            smdLines.forEach((smdLine) => {
-                                const { exists, errors } = checkStreetExists(smdLine.street, currentMunicipality.founder);
-                                if (errors.length > 0) {
-                                    errors.map((error) => {
-                                        console.error(`Line ${lineNumber}: ${error}`);
-                                    });
-                                    warningCount++;
-                                }
-                                if (exists) {
-                                    let addressPoints = findAddressPoints(smdLine, currentFilterMunicipality);
-                                    currentSchool.addresses.push(...filterOutSchoolAddressPoint(addressPoints, currentSchool).map(mapAddressPointForExport));
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        lineNumber++;
-    });
-    if (currentSchool != null) {
-        if (currentMunicipality == null) {
-            currentMunicipality = getNewMunicipality("");
-        }
-        currentMunicipality.schools.push(mapSchoolForExport(currentSchool));
-    }
-    if (currentMunicipality != null) {
-        municipalities.push(convertMunicipality(currentMunicipality));
-    }
-    console.log(`Parsed ${lineNumber} lines, ${errorCount} errors, ${warningCount} warnings.`);
-    if (errorCount > 0) {
-        console.log("Errors:");
-        errorLines.forEach((line) => console.log(line));
-    }
-    return municipalities;
-};
-const filterOutSchoolAddressPoint = (addressPoints, school) => {
-    const schoolPosition = school.position;
-    return schoolPosition && isAddressPoint(schoolPosition)
-        ? (addressPoints = addressPoints.filter((ap) => ap.id !== schoolPosition.id))
-        : addressPoints;
-};
-export const convertMunicipality = (municipality) => {
-    return {
-        municipalityName: municipality.municipalityName,
-        schools: municipality.schools,
-    };
-};

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

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

package/dist/utils/helpers.d.ts

@@ -1,21 +1,5 @@
 import { Founder } from "../db/types";
 export interface OpenDataSyncOptions {
-    tmpDir?: string;
-    dataDir?: string;
-    dbFilePath?: string;
-    dbInitFilePath?: string;
-    addressPointsAtomUrl?: string;
-    addressPointsZipFileName?: string;
-    addressPointsCsvFolderName?: string;
-    streetsAtomUrl?: string;
-    streetZipFolderName?: string;
-    streetDbfFileName?: string;
-    schoolsXmlUrl?: string;
-    schoolsXmlFileName?: string;
-    regionsCsvUrl?: string;
-    regionsCsvFileName?: string;
-}
-export interface OpenDataSyncOptionsNotEmpty {
     tmpDir: string;
     dataDir: string;
     dbFilePath: string;
@@ -24,16 +8,18 @@ export interface OpenDataSyncOptionsNotEmpty {
     addressPointsZipFileName: string;
     addressPointsCsvFolderName: string;
     streetsAtomUrl: string;
-    streetFolderName: string;
+    streetZipFolderName: string;
     streetDbfFileName: string;
     schoolsXmlUrl: string;
     schoolsXmlFileName: string;
     regionsCsvUrl: string;
+    regionsSchemaUrl: string;
     regionsCsvFileName: string;
 }
+export type OpenDataSyncOptionsPartial = Partial<OpenDataSyncOptions>;
 export declare const getAppDataDirPath: () => string;
-export declare const prepareOptions: (options: OpenDataSyncOptions) => OpenDataSyncOptionsNotEmpty;
-export declare const initDb: (options: OpenDataSyncOptionsNotEmpty) => void;
+export declare const prepareOptions: (options: OpenDataSyncOptionsPartial) => OpenDataSyncOptions;
+export declare const initDb: (options: OpenDataSyncOptions) => void;
 export declare const extractMunicipalityName: (founder: Founder) => string;
 export declare const sanitizeMunicipalityName: (name: string) => string;
 export declare const findClosestString: (str: string, arr: string[]) => string;

package/dist/utils/helpers.js

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

package/package.json

@@ -29,14 +29,14 @@
     "ts-node": "^10.9.1"
   },
   "scripts": {
+    "sync-all": "ts-node --experimental-specifier-resolution=node --esm src/bin/sync-all.ts",
     "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",
     "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",
     "clear-all": "ts-node --experimental-specifier-resolution=node --esm src/bin/clear-all.ts",
     "parse-ordinance": "ts-node --experimental-specifier-resolution=node --esm src/bin/parse-ordinance.ts",
-    "diagrams": "ts-node --experimental-specifier-resolution=node --esm src/bin/generate-syntax-diagrams.ts",
-    "streets": "ts-node --experimental-specifier-resolution=node --esm src/bin/streets.ts",
-    "regions": "ts-node --experimental-specifier-resolution=node --esm src/bin/regions.ts",
-    "dbf": "ts-node --experimental-specifier-resolution=node --esm src/bin/dbf.ts",
     "test": "node --experimental-vm-modules --no-warnings node_modules/jest/bin/jest.js -c=jest-esm.config.mjs --no-cache",
     "ordinance-to-csv-rules": "node src/smd-to-csv/ordinance-to-csv-rules.js",
     "clean": "rimraf dist",
@@ -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.5",
+  "version": "1.0.7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [