text-to-map 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Marek Lisy
+
+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.

package/README.md

@@ -0,0 +1,20 @@
+# Text To Map
+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.
+
+## Odkazy
+- [text-to-map-frontend](https://github.com/maral/text-to-map-frontend) - mapa zobrazující výstupy této knihovny
+
+## Živě na webu
+- [Spádové oblasti - Praha](https://mareklisy.cz/spadovosti-praha/)
+
+## Návod na použití
+1. `npm install`
+2. `npm run address-points` - stažení a import adresních bodů z RÚIAN
+3. `npm run schools` - stažení a import dat o školách a zřizovatelích z rejstříku MŠMT
+4. `npm run streets` - dotažení všech ulic z RÚIAN (nepovinné, ale zmizí tím warningy o neexistujících ulicích ve vyhlášce v případech, kdy jsou ve vyhlášce ulice bez jediného adresního bodu)
+5. `npm run parse-ordinance /some/path/input.txt /path/output.json` - parsování vyhlášky a namapování adresních míst na spádové školy
+
+Pro vyzkoušení je možné použít již vyčištěné vyhlášky ze složky *examples*.
+
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/E1E5JOMLT)

package/dist/bin/address-points-import-only.d.ts

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

package/dist/bin/address-points-import-only.js

@@ -0,0 +1,14 @@
+import { importAllLatestAddressPoints } from "../open-data-sync/address-points";
+console.time("importOnly");
+importAllLatestAddressPoints({})
+    .then(() => {
+    console.timeEnd("importOnly");
+})
+    .catch((error) => {
+    if (error.hasOwnProperty("stack")) {
+        console.log(error, error.stack);
+    }
+    else {
+        console.log(error);
+    }
+});

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

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

package/dist/bin/address-points.js

@@ -0,0 +1,14 @@
+import { downloadAndImportAllLatestAddressPoints } from "../open-data-sync/address-points";
+console.time("downloadAndImportAllLatestAddressPoints");
+downloadAndImportAllLatestAddressPoints({})
+    .then(() => {
+    console.timeEnd("downloadAndImportAllLatestAddressPoints");
+})
+    .catch((error) => {
+    if (error.hasOwnProperty("stack")) {
+        console.log(error, error.stack);
+    }
+    else {
+        console.log(error);
+    }
+});

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

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

package/dist/bin/clear-all.js

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

package/dist/bin/generate-syntax-diagrams.d.ts

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

package/dist/bin/generate-syntax-diagrams.js

@@ -0,0 +1,19 @@
+import { writeFileSync } from "fs";
+import { createSyntaxDiagramsCode } from "chevrotain";
+import { smdParser } from "../street-markdown/smd-line-parser";
+// extract the serialized grammar.
+const serializedGrammar = smdParser.getSerializedGastProductions();
+// create the HTML Text
+const htmlText = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>SMD street line Syntax Diagrams</title>
+</head>
+<body>
+${createSyntaxDiagramsCode(serializedGrammar)}
+</body>
+</html>`;
+// Write the HTML file to disk
+writeFileSync("generated_diagrams.html", htmlText);

package/dist/bin/parse-ordinance.d.ts

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

package/dist/bin/parse-ordinance.js

@@ -0,0 +1,20 @@
+import { readFileSync, writeFileSync } from "fs";
+import { parseOrdinanceToAddressPoints } from "../street-markdown/smd";
+// take first node argument as a file name
+if (process.argv.length < 3) {
+    console.error("Missing file name argument");
+    process.exit(1);
+}
+const fileName = process.argv[2];
+const fileContent = readFileSync(fileName);
+const lines = fileContent.toString().split("\n");
+const addressPoints = parseOrdinanceToAddressPoints(lines);
+if (process.argv.length >= 4) {
+    const outputFileName = process.argv[3];
+    const output = JSON.stringify(addressPoints);
+    console.log(`Writing output to ${outputFileName}`);
+    writeFileSync(outputFileName, output);
+}
+else {
+    console.log(JSON.stringify(addressPoints));
+}

package/dist/bin/schools.d.ts

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

package/dist/bin/schools.js

@@ -0,0 +1,8 @@
+import { downloadAndImportAllSchools } from "../open-data-sync/schools";
+downloadAndImportAllSchools({})
+    .then(() => {
+    console.log("Completed");
+})
+    .catch((error) => {
+    console.log(error);
+});

package/dist/bin/streets.d.ts

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

package/dist/bin/streets.js

@@ -0,0 +1,14 @@
+import { downloadAndImportAllStreets } from "../open-data-sync/streets";
+console.time("downloadAndImportAllStreets");
+downloadAndImportAllStreets({})
+    .then(() => {
+    console.timeEnd("downloadAndImportAllStreets");
+})
+    .catch((error) => {
+    if (error.hasOwnProperty("stack")) {
+        console.log(error, error.stack);
+    }
+    else {
+        console.log(error);
+    }
+});

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

@@ -0,0 +1,38 @@
+import { AddressPoint, FullStreetNumber, RangeSpec, SeriesType, SmdLine, WholeMunicipalitySmdLine } from "../street-markdown/types";
+import { Founder, Municipality } from "./types";
+export declare const Column: {
+    admCode: number;
+    cityCode: number;
+    cityName: number;
+    districtCode: number;
+    districtName: number;
+    pragueDistrictCode: number;
+    pragueDistrictName: number;
+    municipalityPartCode: number;
+    municipalityPartName: number;
+    streetCode: number;
+    streetName: number;
+    objectType: number;
+    houseNumber: number;
+    orientationalNumber: number;
+    orientationalNumberLetter: number;
+    postalCode: number;
+    yCoordinate: number;
+    xCoordinate: number;
+    validFrom: number;
+};
+export declare const importParsedLine: (data: string[]) => number;
+export declare const commitAddressPoints: () => number;
+export declare const insertCities: (buffer: string[][]) => number;
+export declare const insertDistricts: (buffer: string[][]) => number;
+export declare const insertMunicipalityParts: (buffer: string[][]) => number;
+export declare const insertStreets: (buffer: string[][]) => number;
+export declare const getAddressPointById: (addressPointId: number) => AddressPoint | null;
+export declare const checkStreetExists: (streetName: string, founder: Founder) => {
+    exists: boolean;
+    errors: string[];
+};
+export declare const findAddressPoints: (smdLine: SmdLine | WholeMunicipalitySmdLine, municipality: Municipality) => AddressPoint[];
+export declare const isInRange: (number: number | null, letter: string | null, range: RangeSpec) => boolean;
+export declare const fitsType: (number: number | null, type: SeriesType) => boolean;
+export declare const equalsFullStreetNumber: (fullStreetNumber: FullStreetNumber, addressPoint: AddressPoint) => boolean;

package/dist/db/address-points.js

@@ -0,0 +1,312 @@
+import { extractKeyValuesPairs, getDb, insertMultipleRows, nonEmptyOrNull, } from "./db";
+import jtsk2wgs84 from "@arodax/jtsk2wgs84";
+import { AddressPointType, isNegativeSeriesSpec, isRange, isSeriesSpecArray, isWholeMunicipalitySmdLine, SeriesType, } from "../street-markdown/types";
+import { MunicipalityType } from "./types";
+import { findClosestString } from "../utils/helpers";
+import { getFounderCityCode } from "./founders";
+import { buildInline } from "../utils/addressBuilder";
+const buffer = [];
+const MaxBufferSize = 1000;
+const DescriptiveType = "č.p.";
+const RegistrationType = "č.ev.";
+const ObjectTypes = {
+    [DescriptiveType]: 1,
+    [RegistrationType]: 2,
+};
+export const Column = {
+    admCode: 0,
+    cityCode: 1,
+    cityName: 2,
+    districtCode: 3,
+    districtName: 4,
+    pragueDistrictCode: 5,
+    pragueDistrictName: 6,
+    municipalityPartCode: 7,
+    municipalityPartName: 8,
+    streetCode: 9,
+    streetName: 10,
+    objectType: 11,
+    houseNumber: 12,
+    orientationalNumber: 13,
+    orientationalNumberLetter: 14,
+    postalCode: 15,
+    yCoordinate: 16,
+    xCoordinate: 17,
+    validFrom: 18,
+};
+export const importParsedLine = (data) => {
+    buffer.push(data);
+    if (buffer.length >= MaxBufferSize) {
+        return commitAddressPoints();
+    }
+    return 0;
+};
+export const commitAddressPoints = () => {
+    if (buffer.length === 0) {
+        return 0;
+    }
+    insertCities(buffer);
+    insertDistricts(buffer);
+    insertMunicipalityParts(buffer);
+    insertStreets(buffer);
+    const db = getDb();
+    const placeHolders = new Array(buffer.length)
+        .fill("(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+        .join(", ");
+    const insertStatement = db.prepare(`INSERT OR IGNORE INTO address_point
+      (id, street_code, object_type_id, descriptive_number, orientational_number, orientational_number_letter, city_code, city_district_code, municipality_part_code, postal_code, jtsk_x, jtsk_y, wgs84_latitude, wgs84_longitude)
+      VALUES ${placeHolders}`);
+    const params = [];
+    buffer.forEach((data) => {
+        let latOrNull, lonOrNull;
+        latOrNull = null;
+        lonOrNull = null;
+        if (data[Column.xCoordinate] && data[Column.yCoordinate]) {
+            const { lat, lon } = jtsk2wgs84(parseFloat(data[Column.xCoordinate]), parseFloat(data[Column.yCoordinate]));
+            [latOrNull, lonOrNull] = [lat.toString(), lon.toString()];
+        }
+        params.push(data[Column.admCode], nonEmptyOrNull(data[Column.streetCode]), ObjectTypes[data[Column.objectType]], nonEmptyOrNull(data[Column.houseNumber]), nonEmptyOrNull(data[Column.orientationalNumber]), nonEmptyOrNull(data[Column.orientationalNumberLetter]), data[Column.cityCode], nonEmptyOrNull(data[Column.districtCode]), nonEmptyOrNull(data[Column.municipalityPartCode]), data[Column.postalCode], nonEmptyOrNull(data[Column.xCoordinate]), nonEmptyOrNull(data[Column.yCoordinate]), latOrNull, lonOrNull);
+    });
+    buffer.length = 0;
+    return insertStatement.run(params).changes;
+};
+export const insertCities = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.cityCode, [Column.cityName]), "city", ["code", "name"]);
+};
+export const insertDistricts = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.districtCode, [
+        Column.cityCode,
+        Column.districtName,
+    ]), "city_district", ["code", "city_code", "name"]);
+};
+export const insertMunicipalityParts = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.municipalityPartCode, [
+        Column.municipalityPartName,
+    ]), "municipality_part", ["code", "name"]);
+};
+export const insertStreets = (buffer) => {
+    return insertMultipleRows(extractKeyValuesPairs(buffer, Column.streetCode, [
+        Column.cityCode,
+        Column.streetName,
+    ]), "street", ["code", "city_code", "name"]);
+};
+const addressPointSelect = `
+  SELECT a.id, s.name AS street_name, o.name AS object_type_name, a.descriptive_number,
+        a.orientational_number, a.orientational_number_letter, c.name AS city_name,
+        m.name AS municipality_part_name, d.name AS district_name, a.postal_code,
+        a.wgs84_latitude, a.wgs84_longitude
+  FROM address_point a
+  LEFT JOIN street s ON a.street_code = s.code
+  INNER JOIN object_type o ON o.id = a.object_type_id
+  INNER JOIN city c ON c.code = a.city_code
+  LEFT JOIN city_district d ON a.city_district_code = d.code
+  LEFT JOIN municipality_part m ON a.municipality_part_code = m.code`;
+export const getAddressPointById = (addressPointId) => {
+    const db = getDb();
+    const statement = db.prepare(`${addressPointSelect}
+      WHERE a.id = ?`);
+    const row = statement.get(addressPointId);
+    if (!row) {
+        return null;
+    }
+    return rowToAddressPoint(row);
+};
+let lastFounder = null;
+let allStreets = [];
+export const checkStreetExists = (streetName, founder) => {
+    const db = getDb();
+    const errors = [];
+    // we check the whole city
+    const cityCode = getFounderCityCode(founder);
+    const statement = db.prepare(`
+    SELECT name AS street_name
+    FROM street
+    WHERE city_code = ? AND name = ? COLLATE NOCASE`);
+    const row = statement.get(cityCode, streetName);
+    if (row) {
+        if (row.street_name !== streetName) {
+            // errors.push(
+            //   `Street '${streetName}' has wrong case, correct case: '${row.street_name}'.`
+            // );
+        }
+        return { exists: true, errors };
+    }
+    if (lastFounder !== founder) {
+        allStreets = getAllStreets(cityCode);
+        lastFounder = founder;
+    }
+    const match = allStreets.find((s) => s.toLocaleLowerCase("cs-CZ") === streetName.toLocaleLowerCase("cs-CZ"));
+    let exists = false;
+    if (match) {
+        exists = true;
+        if (streetName !== match) {
+            // errors.push(
+            //   `Street '${streetName}' has wrong case, correct case: '${match}'.`
+            // );
+        }
+        exists = true;
+    }
+    else {
+        const closest = findClosestString(streetName, allStreets);
+        errors.push(`Street '${streetName}' does not exist, did you mean '${closest}'?`);
+    }
+    return { exists: false, errors };
+};
+const getAllStreets = (cityCode) => {
+    const db = getDb();
+    const statement = db.prepare(`
+    SELECT s.name AS street_name
+    FROM street s
+    WHERE city_code = ?`);
+    const rows = statement.all(cityCode);
+    return rows.map((row) => row.street_name);
+};
+export const findAddressPoints = (smdLine, municipality) => {
+    const db = getDb();
+    const streetJoinCondition = isWholeMunicipalitySmdLine(smdLine)
+        ? "LEFT JOIN street s ON a.street_code = s.code"
+        : "JOIN street s ON a.street_code = s.code AND s.name = ? COLLATE NOCASE";
+    const statement = db.prepare(`
+    SELECT a.id, s.name AS street_name, o.name AS object_type_name, a.descriptive_number,
+          a.orientational_number, a.orientational_number_letter, c.name AS city_name,
+          m.name AS municipality_part_name, d.name AS district_name, a.postal_code,
+          a.wgs84_latitude, a.wgs84_longitude
+    FROM address_point a
+    ${streetJoinCondition}
+    INNER JOIN object_type o ON o.id = a.object_type_id
+    INNER JOIN city c ON c.code = a.city_code
+    LEFT JOIN city_district d ON a.city_district_code = d.code
+    LEFT JOIN municipality_part m ON a.municipality_part_code = m.code
+    WHERE ${getMunicipalityWhere("a", municipality)}`);
+    const params = isWholeMunicipalitySmdLine(smdLine)
+        ? [municipality.code]
+        : [smdLine.street, municipality.code];
+    const filteredAddressPoints = statement.all(...params).map(rowToAddressPoint);
+    if (isWholeMunicipalitySmdLine(smdLine)) {
+        return filteredAddressPoints;
+    }
+    const result = [];
+    const numberSpec = smdLine.numberSpec;
+    if (isSeriesSpecArray(numberSpec)) {
+        numberSpec.forEach((seriesSpec) => {
+            result.push(...filterAddressPointsByRanges(filteredAddressPoints, seriesSpec));
+        });
+        // when no number specs are present, we take everything
+        if (numberSpec.length === 0) {
+            result.push(...filteredAddressPoints);
+        }
+    }
+    else if (isNegativeSeriesSpec(numberSpec)) {
+        // negative number spec (e.g. odd numbers except 13-17)
+        const toExclude = filterAddressPointsByRanges(filteredAddressPoints, numberSpec);
+        result.push(...filteredAddressPoints.filter((addressPoint) => !toExclude.includes(addressPoint)));
+    }
+    return result;
+};
+const filterAddressPointsByRanges = (addressPoints, seriesSpec) => {
+    const result = [];
+    seriesSpec.ranges.forEach((range) => {
+        result.push(...addressPoints.filter((addressPoint) => {
+            var _a;
+            if (isRange(range)) {
+                const number = getNumberByType(seriesSpec.type, addressPoint);
+                return (isInRange(number, seriesSpec.type !== SeriesType.Descriptive
+                    ? (_a = addressPoint.orientationalNumberLetter) !== null && _a !== void 0 ? _a : null
+                    : null, range) && fitsType(number, seriesSpec.type));
+            }
+            else {
+                const fullStreetNumber = range;
+                return equalsFullStreetNumber(fullStreetNumber, addressPoint);
+            }
+        }));
+    });
+    // when no series specs are present, we take everything that fits the type
+    if (seriesSpec.ranges.length === 0) {
+        result.push(...addressPoints.filter((addressPoint) => fitsType(getNumberByType(seriesSpec.type, addressPoint), seriesSpec.type)));
+    }
+    return result;
+};
+export const isInRange = (number, letter, range) => {
+    if (number === null) {
+        return !range.from && !range.to;
+    }
+    // explainer: either the lower bound is not set, or it is lower than the number
+    // if it's equal to the number, we also have to check the letter - if it's not set, we don't care
+    // if from.letter is set, we need to have a letter set and it has to be greater or equal:
+    // number without letter counts lower than number with letter 'a' (e.g. 23 < 23a)
+    const satisfiesFrom = !range.from ||
+        number > range.from.number ||
+        (number === range.from.number &&
+            (!range.from.letter || (!!letter && letter >= range.from.letter)));
+    const satisfiesTo = !range.to ||
+        number < range.to.number ||
+        (number === range.to.number &&
+            (!letter ||
+                (!!range.to.letter && !!letter && letter <= range.to.letter)));
+    return satisfiesFrom && satisfiesTo;
+};
+export const fitsType = (number, type) => {
+    return (type === SeriesType.Descriptive ||
+        type === SeriesType.All ||
+        (type === SeriesType.Odd && number % 2 === 1) ||
+        (type === SeriesType.Even && number % 2 === 0));
+};
+export const equalsFullStreetNumber = (fullStreetNumber, addressPoint) => {
+    return (fullStreetNumber.descriptiveNumber.number ===
+        addressPoint.descriptiveNumber &&
+        fullStreetNumber.orientationalNumber.number ===
+            addressPoint.orientationalNumber &&
+        ((!fullStreetNumber.orientationalNumber.letter &&
+            !addressPoint.orientationalNumberLetter) ||
+            fullStreetNumber.orientationalNumber.letter ===
+                addressPoint.orientationalNumberLetter));
+};
+const getNumberByType = (type, addressPoint) => {
+    var _a;
+    return type === SeriesType.Descriptive
+        ? addressPoint.descriptiveNumber
+        : (_a = addressPoint.orientationalNumber) !== null && _a !== void 0 ? _a : null;
+};
+const getMunicipalityWhere = (alias, municipality) => {
+    return municipality.type === MunicipalityType.City
+        ? `${alias}.city_code = ?`
+        : `${alias}.city_district_code = ?`;
+};
+const createAddress = (result) => {
+    var _a;
+    const orientationalPart = result.orientational_number
+        ? `/${result.orientational_number}${(_a = result.orientational_number_letter) !== null && _a !== void 0 ? _a : ""}`
+        : "";
+    return `${result.street_name} ${result.descriptive_number}${orientationalPart}, ${result.city_name}`;
+};
+const rowToAddressPoint = (row) => {
+    const point = {
+        id: row.id,
+        address: "",
+        type: row.object_type_name === DescriptiveType
+            ? AddressPointType.Descriptive
+            : AddressPointType.Registration,
+        descriptiveNumber: row.descriptive_number,
+        city: row.city_name,
+        postalCode: row.postal_code,
+        lat: row.wgs84_latitude,
+        lng: row.wgs84_longitude,
+    };
+    if (row.street_name !== null) {
+        point.street = row.street_name;
+    }
+    if (row.orientational_number !== null) {
+        point.orientationalNumber = row.orientational_number;
+    }
+    if (row.orientational_number_letter !== null) {
+        point.orientationalNumberLetter = row.orientational_number_letter;
+    }
+    if (row.district_name !== null) {
+        point.district = row.district_name;
+    }
+    if (row.municipality_part_name !== null) {
+        point.municipalityPart = row.municipality_part_name;
+    }
+    point.address = buildInline(point);
+    return point;
+};

package/dist/db/db.d.ts

@@ -0,0 +1,23 @@
+import Database from "better-sqlite3";
+interface DbConfig {
+    initFilePath?: string;
+    filePath?: string;
+    verbose?: boolean;
+}
+export declare const setDbConfig: (config: DbConfig) => void;
+export declare const getDb: (config?: DbConfig) => Database.Database;
+export declare const nonEmptyOrNull: (value: string) => string | null;
+/**
+ * Efficiently insert multiple rows. If preventDuplicatesByFirstColumn is true, the first
+ * column should be unique (PK or UNIQUE).
+ */
+export declare const insertMultipleRows: (rows: string[][], table: string, columnNames: string[], preventDuplicatesByFirstColumn?: boolean) => number;
+/**
+ * Insert a single row and return the autoincremented ID.
+ */
+export declare const insertAutoincrementRow: (row: string[], table: string, columnNames: string[]) => number;
+export declare const deleteMultipleRows: (keys: string[], table: string, keyColumnName: string) => void;
+export declare const clearDuplicates: (rows: string[][], table: string, columnNames: string[]) => string[][];
+export declare const disconnect: () => void;
+export declare const extractKeyValuesPairs: (array: string[][], keyIndex: number, valuesIndices: number[]) => string[][];
+export {};

package/dist/db/db.js

@@ -0,0 +1,90 @@
+import Database from "better-sqlite3";
+import { existsSync, copyFileSync } from "fs";
+import { join } from "path";
+let _db;
+const defaults = {
+    filePath: "address_points.db",
+    initFilePath: join("src", "address_points_init.db"),
+    verbose: false,
+};
+export const setDbConfig = (config) => {
+    _db = undefined;
+    getDb(config);
+};
+export const getDb = (config = {}) => {
+    const options = Object.assign(Object.assign({}, defaults), config);
+    if (typeof _db === "undefined") {
+        if (!existsSync(options.filePath)) {
+            copyFileSync(options.initFilePath, options.filePath);
+        }
+        const dbSettings = options.verbose ? { verbose: console.log } : {};
+        _db = new Database(options.filePath, dbSettings);
+        _db.pragma("journal_mode = WAL");
+    }
+    return _db;
+};
+export const nonEmptyOrNull = (value) => {
+    return value ? value : null;
+};
+/**
+ * Efficiently insert multiple rows. If preventDuplicatesByFirstColumn is true, the first
+ * column should be unique (PK or UNIQUE).
+ */
+export const insertMultipleRows = (rows, table, columnNames, preventDuplicatesByFirstColumn = true) => {
+    const db = getDb();
+    if (rows.length === 0) {
+        return 0;
+    }
+    if (preventDuplicatesByFirstColumn) {
+        rows = clearDuplicates(rows, table, columnNames);
+        if (rows.length === 0) {
+            return 0;
+        }
+    }
+    const insertPlaceholders = generateRepetitiveString(`(${generatePlaceholders(columnNames.length)})`, ",", rows.length);
+    const insertStatement = db.prepare(`INSERT INTO ${table} (${columnNames.join(",")}) VALUES ${insertPlaceholders}`);
+    return insertStatement.run(rows.flat()).changes;
+};
+/**
+ * Insert a single row and return the autoincremented ID.
+ */
+export const insertAutoincrementRow = (row, table, columnNames) => {
+    const db = getDb();
+    const insertStatement = db.prepare(`INSERT INTO ${table} (${columnNames.join(",")}) VALUES (${generatePlaceholders(columnNames.length)})`);
+    return Number(insertStatement.run(row).lastInsertRowid);
+};
+export const deleteMultipleRows = (keys, table, keyColumnName) => {
+    const db = getDb();
+    if (keys.length === 0) {
+        return;
+    }
+    db.prepare(`DELETE FROM ${table} WHERE ${keyColumnName} IN (${generatePlaceholders(keys.length)})`).run(keys);
+};
+export const clearDuplicates = (rows, table, columnNames) => {
+    const db = getDb();
+    const selectPlaceholders = generatePlaceholders(rows.length);
+    const selectStatement = db.prepare(`SELECT ${columnNames[0]} FROM ${table} WHERE ${columnNames[0]} IN (${selectPlaceholders})`);
+    const existing = selectStatement
+        .pluck()
+        .all(rows.map((row) => row[0]))
+        .map((key) => key.toString());
+    return rows.filter((row) => !existing.includes(row[0]));
+};
+export const disconnect = () => {
+    getDb().close();
+};
+const generateRepetitiveString = (value, glue, n) => {
+    return new Array(n).fill(value).join(glue);
+};
+const generatePlaceholders = (n) => {
+    return generateRepetitiveString("?", ",", n);
+};
+export const extractKeyValuesPairs = (array, keyIndex, valuesIndices) => {
+    const object = array.reduce((acc, data) => {
+        if (data[keyIndex]) {
+            acc[data[keyIndex]] = valuesIndices.map((index) => nonEmptyOrNull(data[index]));
+        }
+        return acc;
+    }, {});
+    return Object.keys(object).map((key) => [key, ...object[key]]);
+};

package/dist/db/founders.d.ts

@@ -0,0 +1,9 @@
+import { Founder, MunicipalityType } from "./types";
+import { DbMunicipalityResult } from "../street-markdown/types";
+export declare const insertFounders: (founders: Founder[]) => number;
+export declare const findFounder: (name: string) => {
+    founder: Founder;
+    errors: string[];
+};
+export declare const getFounderCityCode: (founder: Founder) => number;
+export declare const findMunicipalityByNameAndType: (name: string, type: MunicipalityType) => DbMunicipalityResult;