text-to-map 1.0.0

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

@@ -0,0 +1,5 @@
+import { DbMunicipalityResult } from "./types";
+export declare const isMunicipalitySwitch: (line: string) => boolean;
+export declare const getSwitchMunicipality: (line: string) => DbMunicipalityResult;
+export declare const isWholeMunicipality: (line: string) => boolean;
+export declare const getWholeMunicipality: (line: string) => DbMunicipalityResult;

package/dist/street-markdown/municipality.js

@@ -0,0 +1,44 @@
+import { findMunicipalityByNameAndType } from "../db/founders";
+import { MunicipalityType } from "../db/types";
+const municipalitySwitchPattern = /^navíc ulice (z )?(?<type>městské části|městského obvodu|obce|města) (?<name>.+):$/;
+const wholeMunicipalityPattern = /^území (?<type>městské části|městského obvodu|obce|města) (?<name>.+)$/;
+export const isMunicipalitySwitch = (line) => {
+    return municipalitySwitchPattern.test(line);
+};
+export const getSwitchMunicipality = (line) => {
+    const match = municipalitySwitchPattern.exec(line);
+    if (match === null) {
+        throw new Error("Invalid municipality switch line");
+    }
+    const { type, name } = match.groups;
+    return getMunicipalityResult(type, name);
+};
+export const isWholeMunicipality = (line) => {
+    return wholeMunicipalityPattern.test(line);
+};
+export const getWholeMunicipality = (line) => {
+    const match = wholeMunicipalityPattern.exec(line);
+    if (match === null) {
+        return { errors: ["Invalid whole municipality line"], municipality: null };
+    }
+    const { type, name } = match.groups;
+    return getMunicipalityResult(type, name);
+};
+const getMunicipalityResult = (type, name) => {
+    const typeValue = getMunicipalityType(type);
+    const { municipality, errors } = findMunicipalityByNameAndType(name, typeValue);
+    return {
+        municipality,
+        errors,
+    };
+};
+const getMunicipalityType = (type) => {
+    switch (type) {
+        case "městské části":
+        case "městského obvodu":
+            return MunicipalityType.District;
+        case "obce":
+        case "města":
+            return MunicipalityType.City;
+    }
+};

package/dist/street-markdown/roman-numerals.d.ts

@@ -0,0 +1 @@
+export declare const splitStreetViaRomanNumerals: (input: string) => string[];

package/dist/street-markdown/roman-numerals.js

@@ -0,0 +1,67 @@
+let romanNumerals;
+const singleRomanNumeralPattern = /X{1,3}(IX|IV|V?I{0,3})|(IX|IV|VI{0,3})|(I{1,3})/g;
+const romanNumeralsListPattern = /(X{1,3}(IX|IV|V?I{0,3})|(IX|IV|VI{0,3})|(I{1,3}))(, ?(X{1,3}(IX|IV|V?I{0,3})|(IX|IV|VI{0,3})|(I{1,3})))+$/;
+const romanNumeralsRangePattern = /([IVXLCDM]+) ?- ?([IVXLCDM]+)$/;
+export const splitStreetViaRomanNumerals = (input) => {
+    const list = romanNumeralsListPattern.exec(input);
+    if (list) {
+        const streetName = input.substring(0, input.indexOf(list[0])).trim();
+        return extractRomanNumerals(list[0]).map((numeral) => `${streetName} ${numeral}`);
+    }
+    else {
+        const range = romanNumeralsRangePattern.exec(input);
+        if (range) {
+            const streetName = input.substring(0, input.indexOf(range[0])).trim();
+            const bounds = extractRomanNumerals(range[0]);
+            if (!romanNumerals) {
+                romanNumerals = generateRomanNumerals(100);
+            }
+            return romanNumerals
+                .slice(romanNumerals.indexOf(bounds[0]), romanNumerals.indexOf(bounds[1]) + 1)
+                .map((numeral) => `${streetName} ${numeral}`);
+        }
+    }
+    return [input];
+};
+const extractRomanNumerals = (input) => {
+    let n;
+    const numerals = [];
+    do {
+        n = singleRomanNumeralPattern.exec(input);
+        if (n) {
+            numerals.push(n[0]);
+        }
+    } while (n);
+    return numerals;
+};
+// source: ChatGPT
+const generateRomanNumerals = (n) => {
+    const romanNumerals = [];
+    const romanNumeralsMap = new Map([
+        [1000, "M"],
+        [900, "CM"],
+        [500, "D"],
+        [400, "CD"],
+        [100, "C"],
+        [90, "XC"],
+        [50, "L"],
+        [40, "XL"],
+        [10, "X"],
+        [9, "IX"],
+        [5, "V"],
+        [4, "IV"],
+        [1, "I"],
+    ]);
+    for (let i = 1; i <= n; i++) {
+        let number = i;
+        let romanNumeral = "";
+        for (const [value, symbol] of romanNumeralsMap) {
+            while (number >= value) {
+                number -= value;
+                romanNumeral += symbol;
+            }
+        }
+        romanNumerals.push(romanNumeral);
+    }
+    return romanNumerals;
+};

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

@@ -0,0 +1,4 @@
+import { SmdParser } from "./smd-parser";
+import { ProcessedSmdLines } from "./types";
+export declare const smdParser: SmdParser;
+export declare const parseLine: (text: string) => ProcessedSmdLines;

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

@@ -0,0 +1,29 @@
+import { Lexer } from "chevrotain";
+import { SmdParser } from "./smd-parser";
+// const token_definition = require("token_definition");
+import { tokenVocabulary, smdTokens, resetTokenState, prepareLine, } from "./token-definition";
+const printLexingResultInfo = (lexingResult) => {
+    // console.error(JSON.stringify(lexingResult, null, "\t"));
+    const tokens = lexingResult.tokens.map((token) => "'" + token.image + "' (" + token.tokenType.name + ")");
+    console.error(tokens);
+};
+const smdLexer = new Lexer(smdTokens, { positionTracking: "onlyOffset" });
+export const smdParser = new SmdParser(tokenVocabulary);
+export const parseLine = (text) => {
+    resetTokenState(); // this is needed to reset the token state between lines
+    const errors = [];
+    const lexingResult = smdLexer.tokenize(prepareLine(text));
+    if (lexingResult.errors.length > 0) {
+        errors.push(...lexingResult.errors.map((error) => error.message));
+        printLexingResultInfo(lexingResult);
+        return { smdLines: [], errors };
+    }
+    // printLexingResultInfo(lexingResult);
+    smdParser.input = lexingResult.tokens;
+    const smdLines = smdParser.street();
+    if (smdParser.errors.length > 0) {
+        errors.push(...smdParser.errors.map((error) => error.message));
+        printLexingResultInfo(lexingResult);
+    }
+    return { smdLines, errors };
+};

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

@@ -0,0 +1,21 @@
+import { EmbeddedActionsParser, TokenVocabulary } from "chevrotain";
+import { RichNumber, SmdLine } from "./types";
+export declare class SmdParser extends EmbeddedActionsParser {
+    constructor(tokenVocabulary: TokenVocabulary);
+    street: import("chevrotain").ParserMethod<[], SmdLine[]>;
+    private streetNameAndNumbersSpecs;
+    private numberSpecs;
+    private seriesSpecs;
+    private _gatePostfixTypeSeriesSpec;
+    private postfixTypeSeriesSpec;
+    private rangeList;
+    private seriesType;
+    private rangeOrNumber;
+    private range;
+    private fromAndAbove;
+    private fromAndAboveWithType;
+    private toOrBelow;
+    private toOrBelowWithType;
+    private fullStreetNumber;
+}
+export declare const parseRichNumber: (number: string) => RichNumber;

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

@@ -0,0 +1,343 @@
+import { EmbeddedActionsParser, EOF } from "chevrotain";
+import { splitStreetViaRomanNumerals } from "./roman-numerals";
+import { MainSeparator, Separator, OddType, EvenType, DescriptiveType, AllType, Number, Hyphen, StreetName, From, To, AndAbove, AndBelow, Slash, Without, } from "./token-definition";
+import { SeriesType } from "./types";
+export class SmdParser extends EmbeddedActionsParser {
+    constructor(tokenVocabulary) {
+        super(tokenVocabulary);
+        this.street = this.RULE("street", () => {
+            let result;
+            this.OR([
+                {
+                    ALT: () => {
+                        result = this.SUBRULE(this.streetNameAndNumbersSpecs);
+                    },
+                },
+                {
+                    ALT: () => {
+                        result = { street: this.CONSUME(StreetName).image, numberSpec: [] };
+                    },
+                },
+            ]);
+            return splitStreetViaRomanNumerals(result.street).map((street) => ({
+                street,
+                numberSpec: result.numberSpec,
+            }));
+        });
+        this.streetNameAndNumbersSpecs = this.RULE("streetNameAndNumbersSpecs", () => {
+            const street = this.CONSUME(StreetName).image;
+            this.OPTION(() => {
+                this.CONSUME(MainSeparator);
+            });
+            const numberSpec = this.SUBRULE(this.numberSpecs);
+            return { street, numberSpec };
+        });
+        this.numberSpecs = this.RULE("numberSpecs", () => {
+            const result = [];
+            this.OR([
+                {
+                    GATE: () => this.LA(2).tokenType === Without,
+                    ALT: () => {
+                        const type = this.SUBRULE(this.seriesType);
+                        this.CONSUME(Without);
+                        this.OPTION(() => {
+                            this.CONSUME(AllType);
+                        });
+                        const ranges = this.SUBRULE(this.rangeList);
+                        return { negative: true, type, ranges };
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.CONSUME2(Without);
+                        this.OR1([
+                            {
+                                GATE: this._gatePostfixTypeSeriesSpec,
+                                ALT: () => {
+                                    const { type, ranges } = this.SUBRULE(this.postfixTypeSeriesSpec);
+                                    return { negative: true, type, ranges };
+                                },
+                            },
+                            {
+                                ALT: () => {
+                                    const type = this.SUBRULE2(this.seriesType);
+                                    const ranges = this.SUBRULE2(this.rangeList);
+                                    return { negative: true, type, ranges };
+                                },
+                            },
+                        ]);
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.AT_LEAST_ONE_SEP({
+                            SEP: Separator,
+                            DEF: () => {
+                                result.push(this.SUBRULE(this.seriesSpecs));
+                            },
+                        });
+                    },
+                },
+            ]);
+            return result;
+        });
+        this.seriesSpecs = this.RULE("seriesSpecs", () => {
+            let ranges = [];
+            let type;
+            this.OR([
+                {
+                    GATE: this._gatePostfixTypeSeriesSpec,
+                    ALT: () => {
+                        ({ type, ranges } = this.SUBRULE(this.postfixTypeSeriesSpec));
+                    },
+                },
+                {
+                    ALT: () => {
+                        type = this.SUBRULE(this.seriesType);
+                        this.OPTION(() => {
+                            ranges = this.SUBRULE(this.rangeList);
+                        });
+                    },
+                },
+                {
+                    ALT: () => {
+                        ({ type, ranges } = this.SUBRULE2(this.fromAndAboveWithType));
+                    },
+                },
+                {
+                    ALT: () => {
+                        ({ type, ranges } = this.SUBRULE(this.toOrBelowWithType));
+                    },
+                },
+            ]);
+            return { type, ranges };
+        });
+        this._gatePostfixTypeSeriesSpec = () => {
+            let index = 2;
+            while (![Separator, EOF].includes(this.LA(index).tokenType)) {
+                if ([OddType, EvenType].includes(this.LA(index).tokenType)) {
+                    return true;
+                }
+                index++;
+            }
+            return false;
+        };
+        this.postfixTypeSeriesSpec = this.RULE("postfixTypeSeriesSpec", () => {
+            this.CONSUME(AllType);
+            const ranges = [this.SUBRULE(this.rangeOrNumber)];
+            let type;
+            this.OR1([
+                {
+                    ALT: () => {
+                        this.CONSUME(OddType);
+                        type = SeriesType.Odd;
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.CONSUME1(EvenType);
+                        type = SeriesType.Even;
+                    },
+                },
+            ]);
+            return { type, ranges };
+        });
+        this.rangeList = this.RULE("rangeList", () => {
+            let ranges = [];
+            ranges.push(this.SUBRULE(this.rangeOrNumber));
+            this.MANY({
+                GATE: () => [Number, To, From].includes(this.LA(2).tokenType),
+                DEF: () => {
+                    this.CONSUME(Separator);
+                    ranges.push(this.SUBRULE2(this.rangeOrNumber));
+                },
+            });
+            return ranges;
+        });
+        this.seriesType = this.RULE("seriesType", () => {
+            let type;
+            this.OR([
+                {
+                    ALT: () => {
+                        this.CONSUME(OddType);
+                        type = SeriesType.Odd;
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.CONSUME1(EvenType);
+                        type = SeriesType.Even;
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.CONSUME2(AllType);
+                        type = SeriesType.All;
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.CONSUME3(DescriptiveType);
+                        type = SeriesType.Descriptive;
+                    },
+                },
+            ]);
+            return type;
+        });
+        this.rangeOrNumber = this.RULE("rangeOrNumber", () => {
+            let result;
+            this.OR([
+                {
+                    ALT: () => {
+                        result = this.SUBRULE(this.range);
+                    },
+                },
+                {
+                    ALT: () => {
+                        result = this.SUBRULE(this.fromAndAbove);
+                    },
+                },
+                {
+                    ALT: () => {
+                        result = this.SUBRULE(this.toOrBelow);
+                    },
+                },
+                {
+                    ALT: () => {
+                        result = this.SUBRULE(this.fullStreetNumber);
+                    },
+                },
+                {
+                    ALT: () => {
+                        const n = parseRichNumber(this.CONSUME(Number).image);
+                        result = { from: n, to: n };
+                    },
+                },
+            ]);
+            return result;
+        });
+        this.range = this.RULE("range", () => {
+            const from = parseRichNumber(this.CONSUME(Number).image);
+            this.OR([
+                { ALT: () => this.CONSUME1(Hyphen) },
+                { ALT: () => this.CONSUME2(MainSeparator) },
+            ]);
+            this.OPTION(() => {
+                this.CONSUME(AllType);
+            });
+            const to = parseRichNumber(this.CONSUME3(Number).image);
+            return { from, to };
+        });
+        this.fromAndAbove = this.RULE("fromAndAbove", () => {
+            let from;
+            this.OR([
+                {
+                    ALT: () => {
+                        from = parseRichNumber(this.CONSUME(Number).image);
+                        this.CONSUME(AndAbove);
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.CONSUME(From);
+                        this.OPTION(() => {
+                            this.CONSUME(AllType);
+                        });
+                        from = parseRichNumber(this.CONSUME2(Number).image);
+                        this.OPTION2(() => {
+                            this.CONSUME2(AndAbove);
+                        });
+                    },
+                },
+            ]);
+            return { from };
+        });
+        this.fromAndAboveWithType = this.RULE("fromAndAboveWithType", () => {
+            let type = SeriesType.All;
+            this.CONSUME(From);
+            this.OPTION(() => {
+                this.OR([
+                    {
+                        ALT: () => {
+                            type = SeriesType.All;
+                            this.CONSUME(AllType);
+                        },
+                    },
+                    {
+                        ALT: () => {
+                            type = SeriesType.Descriptive;
+                            this.CONSUME(DescriptiveType);
+                        },
+                    },
+                ]);
+            });
+            const from = parseRichNumber(this.CONSUME(Number).image);
+            this.OPTION2(() => {
+                this.CONSUME(AndAbove);
+            });
+            return { type, ranges: [{ from }] };
+        });
+        this.toOrBelow = this.RULE("toOrBelow", () => {
+            let to;
+            this.OR([
+                {
+                    ALT: () => {
+                        to = parseRichNumber(this.CONSUME(Number).image);
+                        this.CONSUME(AndBelow);
+                    },
+                },
+                {
+                    ALT: () => {
+                        this.CONSUME2(To);
+                        to = parseRichNumber(this.CONSUME2(Number).image);
+                    },
+                },
+            ]);
+            return { to };
+        });
+        this.toOrBelowWithType = this.RULE("toOrBelowWithType", () => {
+            let type = SeriesType.All;
+            this.CONSUME(To);
+            this.OPTION(() => {
+                this.OR([
+                    {
+                        ALT: () => {
+                            type = SeriesType.All;
+                            this.CONSUME(AllType);
+                        },
+                    },
+                    {
+                        ALT: () => {
+                            type = SeriesType.Descriptive;
+                            this.CONSUME(DescriptiveType);
+                        },
+                    },
+                ]);
+            });
+            const to = parseRichNumber(this.CONSUME(Number).image);
+            return { type, ranges: [{ to }] };
+        });
+        this.fullStreetNumber = this.RULE("fullStreetNumber", () => {
+            const descriptiveNumber = parseRichNumber(this.CONSUME(Number).image);
+            this.CONSUME(Slash);
+            const orientationNumber = parseRichNumber(this.CONSUME2(Number).image);
+            return { descriptiveNumber, orientationalNumber: orientationNumber };
+        });
+        this.performSelfAnalysis();
+    }
+}
+const numberWithCharacterPattern = /^(\d+)([a-z])$/;
+export const parseRichNumber = (number) => {
+    if (numberWithCharacterPattern.test(number)) {
+        const match = numberWithCharacterPattern.exec(number);
+        return {
+            number: parseInt(match[1]),
+            letter: match[2],
+        };
+    }
+    else {
+        return {
+            number: parseInt(number),
+        };
+    }
+};

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

@@ -0,0 +1,9 @@
+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[];
+export declare const convertMunicipality: (municipality: MunicipalityWithFounder) => Municipality;
+export {};