text-to-map 1.1.18 → 1.1.19

package/dist/bin/parse-ordinance.js

@@ -36,9 +36,15 @@ function main() {
         };
         console.time("downloadAndImportAllLatestAddressPoints");
         const { municipality } = yield getNewMunicipalityByName("Česká Lípa");
-        const addressPoints = yield parseOrdinanceToAddressPoints(lines, {
-        // currentMunicipality: municipality,
-        }, reportErrors, reportWarnings);
+        const addressPoints = yield parseOrdinanceToAddressPoints({
+            lines,
+            initialState: {
+            // currentMunicipality: municipality,
+            },
+            onError: reportErrors,
+            onWarning: reportWarnings,
+            includeUnmappedAddressPoints: true,
+        });
         console.timeEnd("downloadAndImportAllLatestAddressPoints");
         console.log(`Parsed ${lines.length} lines, ${errorCount} errors, ${warningCount} warnings.`);
         if (errorCount > 0) {

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

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

package/dist/street-markdown/smd.js

@@ -15,12 +15,13 @@ import { founderToMunicipality } from "../db/types";
 import { getMunicipalityPartResult, getRestOfMunicipalityPart, getSwitchMunicipality, getWholeMunicipality, isMunicipalitySwitch, isRestOfMunicipalityLine, isRestOfMunicipalityPartLine, isRestWithNoStreetNameLine, isWholeMunicipality, } from "./municipality";
 import { parseLine } from "./smd-line-parser";
 import { isAddressPoint, } from "./types";
-export const parseOrdinanceToAddressPoints = (lines, initialState = {}, onError = () => { }, onWarning = () => { }, onProcessedLine = () => { }) => __awaiter(void 0, void 0, void 0, function* () {
+export const parseOrdinanceToAddressPoints = ({ lines, initialState = {}, onError = () => { }, onWarning = () => { }, onProcessedLine = () => { }, includeUnmappedAddressPoints = false, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const state = Object.assign({ currentMunicipality: null, currentFilterMunicipality: null, currentSchool: null, rests: {
                 noStreetNameSchoolIzo: null,
                 municipalityParts: [],
                 wholeMunicipalitySchoolIzo: null,
+                includeUnmappedAddressPoints,
             }, municipalities: [] }, initialState);
         let lineNumber = 1;
         for (const rawLine of lines) {
@@ -61,6 +62,7 @@ export const convertMunicipality = (municipality) => {
     return {
         municipalityName: municipality.municipalityName,
         schools: municipality.schools,
+        unmappedPoints: municipality.unmappedPoints,
     };
 };
 const processOneLine = (params) => __awaiter(void 0, void 0, void 0, function* () {
@@ -210,14 +212,14 @@ const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning,
         }
     }
 });
-const addRestToSchool = (restPoints, schoolIzo, state) => __awaiter(void 0, void 0, void 0, function* () {
+const addRestToSchool = (restPoints, schoolIzo, state) => {
     const addressPoints = state.currentMunicipality.schools.flatMap((school) => school.addresses);
     // filter out address points already present
     const remainingPoints = restPoints.filter((point) => !addressPoints.some((ap) => ap.address === point.address));
     // find the right school and add the remaining address points
     const schoolIndex = state.currentMunicipality.schools.findIndex((school) => school.izo === schoolIzo);
     state.currentMunicipality.schools[schoolIndex].addresses.push(...remainingPoints);
-});
+};
 const addRests = (state) => __awaiter(void 0, void 0, void 0, function* () {
     if (state.rests.noStreetNameSchoolIzo) {
         yield addRestWithNoStreetNameToSchool(state);
@@ -228,6 +230,9 @@ const addRests = (state) => __awaiter(void 0, void 0, void 0, function* () {
     for (const rest of state.rests.municipalityParts) {
         yield addRestOfMunicipalityPart(state, rest.municipalityPartCode, rest.schoolIzo);
     }
+    if (state.rests.includeUnmappedAddressPoints) {
+        yield addRestOfMunicipalityToUnmappedPoints(state);
+    }
     state.rests.noStreetNameSchoolIzo = null;
     state.rests.wholeMunicipalitySchoolIzo = null;
     state.rests.municipalityParts = [];
@@ -241,18 +246,23 @@ const addRestWithNoStreetNameToSchool = (state) => __awaiter(void 0, void 0, voi
             type: state.currentMunicipality.founder.municipalityType,
         },
     });
-    yield addRestToSchool(pointsNoStreetName, state.rests.noStreetNameSchoolIzo, state);
+    addRestToSchool(pointsNoStreetName, state.rests.noStreetNameSchoolIzo, state);
 });
 const addRestOfMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
+    addRestToSchool(yield getRestOfMunicipality(state), state.rests.wholeMunicipalitySchoolIzo, state);
+});
+const addRestOfMunicipalityToUnmappedPoints = (state) => __awaiter(void 0, void 0, void 0, function* () {
+    state.currentMunicipality.unmappedPoints = (yield getRestOfMunicipality(state)).map(mapAddressPointForExport);
+});
+const getRestOfMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points for current municipality
-    const allPoints = yield findAddressPoints({
+    return yield findAddressPoints({
         type: "wholeMunicipality",
         municipality: {
             code: state.currentMunicipality.founder.cityOrDistrictCode,
             type: state.currentMunicipality.founder.municipalityType,
         },
     });
-    yield addRestToSchool(allPoints, state.rests.wholeMunicipalitySchoolIzo, state);
 });
 const addRestOfMunicipalityPart = (state, municipalityPartCode, schoolIzo) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points for current municipality
@@ -260,7 +270,7 @@ const addRestOfMunicipalityPart = (state, municipalityPartCode, schoolIzo) => __
         type: "wholeMunicipalityPart",
         municipalityPartCode,
     });
-    yield addRestToSchool(allPoints, schoolIzo, state);
+    addRestToSchool(allPoints, schoolIzo, state);
 });
 export const getNewMunicipalityByName = (name) => __awaiter(void 0, void 0, void 0, function* () {
     const { founder, errors } = yield findFounder(name);
@@ -275,6 +285,7 @@ const getNewMunicipality = (founder, errors) => ({
         municipalityName: founder ? founder.name : "Neznámá obec",
         founder,
         schools: [],
+        unmappedPoints: [],
     },
     errors,
 });

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

@@ -64,6 +64,7 @@ export interface School {
 export interface Municipality {
     municipalityName: string;
     schools: School[];
+    unmappedPoints: ExportAddressPoint[];
 }
 export interface DbMunicipalityResult {
     municipality: DbMunicipality;
@@ -76,6 +77,10 @@ export interface MunicipalityPartResult {
 export interface MunicipalityWithFounder extends Municipality {
     founder: Founder | null;
 }
+export interface MunicipalityWithFounderResult {
+    municipality: MunicipalityWithFounder;
+    errors: SmdError[];
+}
 export interface SmdState {
     currentMunicipality: MunicipalityWithFounder;
     currentFilterMunicipality: DbMunicipality;
@@ -87,6 +92,7 @@ export interface SmdState {
             schoolIzo: string;
         }[];
         wholeMunicipalitySchoolIzo: string;
+        includeUnmappedAddressPoints: boolean;
     };
     municipalities: Municipality[];
 }

package/package.json

@@ -57,7 +57,7 @@
   },
   "name": "text-to-map",
   "description": "Text To Map usiluje o lepší, strojově zpracovatelné využití částí vyhlášek s výčtem ulic a dalších lokací. Jde o rozšiřitelnou sadu konceptů a nástrojů, které zajistí hladký převod výčtu ulic a jejich rozsahů v lidsky srozumitelném jazyce do strojově zpracovatelného, uchopitelného formátu.",
-  "version": "1.1.18",
+  "version": "1.1.19",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [