text-to-map 1.0.0

package/dist/street-markdown/smd.js

@@ -0,0 +1,182 @@
+import { checkStreetExists, findAddressPoints, getAddressPointById, } from "../db/address-points";
+import { setDbConfig } from "../db/db";
+import { findFounder } from "../db/founders";
+import { findSchool } from "../db/schools";
+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) => {
+    const { founder, errors } = findFounder(name);
+    if (errors.length > 0) {
+        errors.forEach(console.error);
+    }
+    return {
+        municipalityName: founder ? founder.name : "Neznámá obec",
+        founder,
+        schools: [],
+    };
+};
+const getNewSchool = (name, founder) => {
+    let exportSchool = {
+        name: name,
+        izo: "",
+        addresses: [],
+    };
+    if (founder !== null) {
+        const { school } = findSchool(name, founder.schools);
+        if (school) {
+            school.izo = school.izo || "";
+            if (school.locations.length > 0) {
+                const position = getAddressPointById(school.locations[0].addressPointId);
+                if (position !== null) {
+                    exportSchool.position = position;
+                }
+            }
+        }
+    }
+    return exportSchool;
+};
+const mapAddressPointForExport = (addressPoint) => {
+    return {
+        address: addressPoint.address,
+        lat: addressPoint.lat,
+        lng: addressPoint.lng,
+    };
+};
+const mapSchoolForExport = (school) => ({
+    name: school.name,
+    izo: school.izo,
+    addresses: school.addresses,
+    position: mapAddressPointForExport(school.position),
+});
+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/token-definition.d.ts

@@ -0,0 +1,23 @@
+import { TokenVocabulary } from "chevrotain";
+export declare const resetTokenState: () => void;
+export declare const prepareLine: (text: string) => string;
+export declare const streetNameMatcher: (text: string, startOffset: number) => RegExpExecArray | [string] | null;
+declare const MainSeparator: import("chevrotain").TokenType;
+declare const From: import("chevrotain").TokenType;
+declare const To: import("chevrotain").TokenType;
+declare const AndAbove: import("chevrotain").TokenType;
+declare const AndBelow: import("chevrotain").TokenType;
+declare const Separator: import("chevrotain").TokenType;
+declare const DescriptiveType: import("chevrotain").TokenType;
+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 StreetName: import("chevrotain").TokenType;
+declare const Number: import("chevrotain").TokenType;
+declare const Hyphen: import("chevrotain").TokenType;
+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, };

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

@@ -0,0 +1,154 @@
+import { createToken, Lexer } from "chevrotain";
+let streetNameWasMatched = false;
+export const resetTokenState = () => {
+    streetNameWasMatched = false;
+};
+export const prepareLine = (text) => {
+    return text
+        .replace(/([IVXLCDM]+) - ([IVXLCDM]+)/, "$1-$2")
+        .replace(/;/g, ",")
+        .replace(/,$/, "");
+};
+const tokenBlockerFactory = (pattern) => {
+    const stickyPattern = new RegExp(pattern, "y");
+    return (text, startOffset) => {
+        if (streetNameWasMatched) {
+            stickyPattern.lastIndex = startOffset;
+            return stickyPattern.exec(text);
+        }
+        else {
+            return null;
+        }
+    };
+};
+const interruptPatterns = [
+    "lichá",
+    "sudá",
+    "č.",
+    "od",
+    "do",
+    "pouze",
+    "všechna",
+    "bez",
+    "vyjma",
+    "mimo",
+    "s výjimkou",
+    "kromě",
+];
+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()];
+            }
+        }
+        return result;
+    }
+};
+const MainSeparator = createToken({ name: "MainSeparator", pattern: / - / });
+const From = createToken({ name: "From", pattern: /od/ });
+const To = createToken({ name: "To", pattern: /do/ });
+const AndAbove = createToken({
+    name: "AndAbove",
+    pattern: / (a )?(výše?|vyšší)/,
+});
+const AndBelow = createToken({
+    name: "AndBelow",
+    pattern: / a (níže?|nižší)/,
+});
+const Separator = createToken({
+    name: "Separator",
+    pattern: /,| a /,
+    longer_alt: [AndAbove, AndBelow],
+});
+const DescriptiveType = createToken({
+    name: "CPType",
+    pattern: /(pouze |všechna )?č. ?p./,
+});
+const AllType = createToken({
+    name: "AllType",
+    pattern: /(pouze |všechna )?(č(\.|ísla)( ?o\.)?|lichá i sudá)/,
+    longer_alt: DescriptiveType,
+});
+const OddType = createToken({
+    name: "OddType",
+    pattern: /(pouze |všechna )?(lich([áé]|ých)( č(\.|ísla))?( ?o\.)?|č(\.|ísla)( ?o\.)? lich[áé])/,
+    longer_alt: AllType,
+});
+const EvenType = createToken({
+    name: "EvenType",
+    pattern: /(pouze |všechna )?(sud([áé]|ých)( č(\.|ísla))?( ?o\.)?|č(\.|ísla)( ?o\.)? sud[áé])/,
+});
+const Without = createToken({
+    name: "Without",
+    pattern: /bez|vyjma|mimo|s výjimkou|kromě/,
+});
+const StreetName = createToken({
+    name: "StreetName",
+    pattern: streetNameMatcher,
+});
+const Number = createToken({
+    name: "Number",
+    pattern: tokenBlockerFactory(/\d+[a-zA-Z]?/),
+});
+const Hyphen = createToken({ name: "Hyphen", pattern: /-|až/ });
+const Slash = createToken({ name: "Hyphen", pattern: /\// });
+const Space = createToken({
+    name: "Space",
+    pattern: / +/,
+    longer_alt: [MainSeparator, Separator],
+    group: Lexer.SKIPPED,
+});
+const Colon = createToken({
+    name: "Colon",
+    pattern: /:/,
+    group: Lexer.SKIPPED,
+});
+const smdTokens = [
+    MainSeparator,
+    Separator,
+    OddType,
+    EvenType,
+    DescriptiveType,
+    AllType,
+    Number,
+    From,
+    To,
+    AndAbove,
+    AndBelow,
+    Without,
+    Hyphen,
+    Slash,
+    Space,
+    Colon,
+    StreetName,
+];
+MainSeparator.LABEL = "' - '";
+Separator.LABEL = "','";
+Hyphen.LABEL = "'-'";
+Slash.LABEL = "'/'";
+From.LABEL = "'od'";
+To.LABEL = "'do'";
+AndAbove.LABEL = "'a výše'";
+AndBelow.LABEL = "'a níže'";
+Space.LABEL = "' '";
+OddType.LABEL = "'lichá č.'";
+EvenType.LABEL = "'sudá č.'";
+DescriptiveType.LABEL = "'č. p.'";
+AllType.LABEL = "'č.'";
+Without.LABEL = "'bez'";
+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, };

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

@@ -0,0 +1,83 @@
+import { Municipality as DbMunicipality } from "../db/types";
+export interface ProcessedSmdLines {
+    smdLines: SmdLine[];
+    errors: string[];
+}
+export interface SmdLine {
+    street: string;
+    numberSpec: SeriesSpec[] | NegativeSeriesSpec;
+}
+export interface WholeMunicipalitySmdLine extends SmdLine {
+    wholeMunicipality: true;
+    street: string;
+    numberSpec: SeriesSpec[] | NegativeSeriesSpec;
+}
+export declare const isWholeMunicipalitySmdLine: (something: SmdLine | WholeMunicipalitySmdLine) => something is WholeMunicipalitySmdLine;
+export interface SeriesSpec {
+    type: SeriesType;
+    ranges: (RangeSpec | FullStreetNumber)[];
+}
+export interface NegativeSeriesSpec extends SeriesSpec {
+    negative: true;
+}
+export declare const isSeriesSpecArray: (something: SeriesSpec[] | NegativeSeriesSpec) => something is SeriesSpec[];
+export declare const isNegativeSeriesSpec: (something: SeriesSpec[] | NegativeSeriesSpec) => something is SeriesSpec[];
+export interface RangeSpec {
+    from?: RichNumber;
+    to?: RichNumber;
+}
+export interface RichNumber {
+    number: number;
+    letter?: string;
+}
+export interface FullStreetNumber {
+    descriptiveNumber: RichNumber;
+    orientationalNumber: RichNumber;
+}
+export declare const isFullStreetNumber: (something: RangeSpec | FullStreetNumber) => something is FullStreetNumber;
+export declare const isRange: (something: RangeSpec | FullStreetNumber) => something is RangeSpec;
+export declare enum SeriesType {
+    Even = 0,
+    Odd = 1,
+    All = 2,
+    Descriptive = 3
+}
+export declare enum AddressPointType {
+    Descriptive = 0,
+    Registration = 1
+}
+export interface AddressPoint {
+    id: number;
+    address: string;
+    type: AddressPointType;
+    street?: string;
+    descriptiveNumber: number;
+    orientationalNumber?: number;
+    orientationalNumberLetter?: string;
+    postalCode: string;
+    city: string;
+    district?: string;
+    municipalityPart?: string;
+    lat: number;
+    lng: number;
+}
+export interface ExportAddressPoint {
+    address: string;
+    lat: number;
+    lng: number;
+}
+export declare const isAddressPoint: (something: AddressPoint | ExportAddressPoint) => something is AddressPoint;
+export interface School {
+    name: string;
+    izo: string;
+    position?: AddressPoint | ExportAddressPoint;
+    addresses: ExportAddressPoint[];
+}
+export interface Municipality {
+    municipalityName: string;
+    schools: School[];
+}
+export interface DbMunicipalityResult {
+    municipality: DbMunicipality;
+    errors: string[];
+}

package/dist/street-markdown/types.js

@@ -0,0 +1,18 @@
+export const isWholeMunicipalitySmdLine = (something) => something.hasOwnProperty("wholeMunicipality");
+export const isSeriesSpecArray = (something) => Array.isArray(something);
+export const isNegativeSeriesSpec = (something) => something.hasOwnProperty("negative");
+export const isFullStreetNumber = (something) => something.hasOwnProperty("orientationNumber");
+export const isRange = (something) => !something.hasOwnProperty("orientationNumber");
+export var SeriesType;
+(function (SeriesType) {
+    SeriesType[SeriesType["Even"] = 0] = "Even";
+    SeriesType[SeriesType["Odd"] = 1] = "Odd";
+    SeriesType[SeriesType["All"] = 2] = "All";
+    SeriesType[SeriesType["Descriptive"] = 3] = "Descriptive";
+})(SeriesType || (SeriesType = {}));
+export var AddressPointType;
+(function (AddressPointType) {
+    AddressPointType[AddressPointType["Descriptive"] = 0] = "Descriptive";
+    AddressPointType[AddressPointType["Registration"] = 1] = "Registration";
+})(AddressPointType || (AddressPointType = {}));
+export const isAddressPoint = (something) => something.hasOwnProperty("id");

package/dist/utils/addressBuilder.d.ts

@@ -0,0 +1,8 @@
+import { AddressPoint } from "../street-markdown/types";
+export interface ThreeRowsAddress {
+    firstRow: string;
+    secondRow: string;
+    thirdRow: string;
+}
+export declare const buildInline: (address: AddressPoint) => string;
+export declare const build: (address: AddressPoint) => ThreeRowsAddress;

package/dist/utils/addressBuilder.js

@@ -0,0 +1,101 @@
+/*
+  Taken from https://github.com/letomas/RUIAN-search and rewritten to typescript.
+
+MIT License
+
+Copyright (c) 2020 Tomáš Le
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+import { AddressPointType } from "../street-markdown/types";
+export const buildInline = (address) => {
+    const addressInRows = build(address);
+    let result = addressInRows.firstRow + ", " + addressInRows.secondRow;
+    if (addressInRows.thirdRow) {
+        result += ", " + addressInRows.thirdRow;
+    }
+    return result;
+};
+export const build = (address) => {
+    const result = {
+        firstRow: "",
+        secondRow: "",
+        thirdRow: "",
+    };
+    if (!!address.street && !districtEqualsCity(address)) {
+        result.secondRow = address.district;
+    }
+    if (!address.street) {
+        if (address.city === address.district) {
+            let buildingType = address.type === AddressPointType.Registration ? " č. ev. " : "č. p. ";
+            result.firstRow = buildingType + address.descriptiveNumber;
+        }
+        else {
+            result.firstRow = address.district;
+            result.firstRow += " " + buildHouseNumber(address);
+        }
+        result.firstRow += buildOrientationalNumber(address);
+        buildLastRow(result, address);
+        return result;
+    }
+    result.firstRow = address.street;
+    result.firstRow += " " + buildHouseNumber(address);
+    result.firstRow += buildOrientationalNumber(address);
+    buildLastRow(result, address);
+    return result;
+};
+const buildHouseNumber = (address) => {
+    if (address.type === AddressPointType.Registration) {
+        return "č. ev. " + address.descriptiveNumber;
+    }
+    return address.descriptiveNumber;
+};
+const buildOrientationalNumber = (address) => {
+    var _a;
+    if (address.orientationalNumber) {
+        return ("/" +
+            address.orientationalNumber +
+            ((_a = address.orientationalNumberLetter) !== null && _a !== void 0 ? _a : ""));
+    }
+    return "";
+};
+const buildLastRow = (result, address) => {
+    // if (!result.secondRow) {
+    //   if (address.city === "Praha") {
+    //     result.secondRow = address.postalCode + " " + address.pragueBoroughName;
+    //   } else {
+    //     result.secondRow = address.postalCode + " " + address.cityName;
+    //   }
+    // } else {
+    //   if (address.cityName === "Praha") {
+    //     result.thirdRow = address.postalCode + " " + address.pragueBoroughName;
+    //   } else {
+    //     result.thirdRow = address.postalCode + " " + address.cityName;
+    //   }
+    // }
+    if (!result.secondRow) {
+        result.secondRow = address.postalCode + " " + address.city;
+    }
+    else {
+        result.thirdRow = address.postalCode + " " + address.city;
+    }
+};
+const districtEqualsCity = (address) => {
+    return address.district === address.city;
+};

package/dist/utils/atom.d.ts

@@ -0,0 +1,2 @@
+export declare const getLatestUrlFromAtomFeed: (atomFeedUrl: string) => Promise<string>;
+export declare const getAllUrlsFromAtomFeed: (atomFeedUrl: string) => Promise<string[]>;

package/dist/utils/atom.js

@@ -0,0 +1,65 @@
+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 FeedParser from "feedparser";
+import fetch from "node-fetch";
+import { pipeline } from "stream/promises";
+export const getLatestUrlFromAtomFeed = (atomFeedUrl) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(atomFeedUrl);
+    const feedparser = new FeedParser({});
+    let link = null;
+    if (response.status !== 200) {
+        throw new Error(`The Atom feed from atom.cuzk.cz not working. HTTP status ${response.status}`);
+    }
+    feedparser.on("error", (error) => {
+        throw new Error(`The Atom feed from atom.cuzk.cz could not be loaded.`);
+    });
+    feedparser.on("readable", function () {
+        let item;
+        let maxDate = new Date();
+        maxDate.setFullYear(1990);
+        while ((item = this.read())) {
+            if (item.date > maxDate) {
+                maxDate = item.date;
+                link = item.link;
+            }
+        }
+    });
+    yield pipeline(response.body, feedparser);
+    if (link != null) {
+        return link;
+    }
+    else {
+        throw new Error("Could not find any dataset feed link.");
+    }
+});
+export const getAllUrlsFromAtomFeed = (atomFeedUrl) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(atomFeedUrl);
+    const feedparser = new FeedParser({});
+    const links = [];
+    if (response.status !== 200) {
+        throw new Error(`The Atom feed from atom.cuzk.cz not working. HTTP status ${response.status}`);
+    }
+    feedparser.on("error", (error) => {
+        throw new Error(`The Atom feed from atom.cuzk.cz could not be loaded.`);
+    });
+    feedparser.on("readable", function () {
+        let item;
+        while ((item = this.read())) {
+            links.push(item.link);
+        }
+    });
+    yield pipeline(response.body, feedparser);
+    if (links.length > 0) {
+        return links;
+    }
+    else {
+        throw new Error("Could not find any dataset feed link.");
+    }
+});

package/dist/utils/helpers.d.ts

@@ -0,0 +1,34 @@
+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;
+}
+export interface OpenDataSyncOptionsNotEmpty {
+    tmpDir: string;
+    dataDir: string;
+    dbFilePath: string;
+    dbInitFilePath: string;
+    addressPointsAtomUrl: string;
+    addressPointsZipFileName: string;
+    addressPointsCsvFolderName: string;
+    streetsAtomUrl: string;
+    streetFolderName: string;
+    streetDbfFileName: string;
+    schoolsXmlUrl: string;
+    schoolsXmlFileName: string;
+}
+export declare const getAppDataDirPath: () => string;
+export declare const prepareOptions: (options: OpenDataSyncOptions) => OpenDataSyncOptionsNotEmpty;
+export declare const initDb: (options: OpenDataSyncOptionsNotEmpty) => void;
+export declare const extractMunicipalityName: (founder: Founder) => string;
+export declare const findClosestString: (str: string, arr: string[]) => string;