minotor 1.0.0

package/src/stops/__tests__/stopFinder.test.ts

@@ -0,0 +1,185 @@
+import assert from 'node:assert';
+import { beforeEach, describe, it } from 'node:test';
+
+import { StopsMap } from '../stops.js';
+import { StopsIndex } from '../stopsIndex.js';
+const mockStops: StopsMap = new Map([
+  [
+    '8587255',
+    {
+      id: '8587255',
+      name: 'Fribourg, Tilleul/Cathédrale',
+      lat: 46.8061375857565,
+      lon: 7.16145029437328,
+      children: [],
+      locationType: 'SIMPLE_STOP_OR_PLATFORM',
+    },
+  ],
+  [
+    '8592383',
+    {
+      id: '8592383',
+      name: 'Fribourg, Neuveville/Court-Ch.',
+      lat: 46.8042990960992,
+      lon: 7.16060587800609,
+      children: [],
+      locationType: 'SIMPLE_STOP_OR_PLATFORM',
+    },
+  ],
+  [
+    '8592386',
+    {
+      id: '8592386',
+      name: 'Fribourg, Petit-St-Jean',
+      lat: 46.8035550740648,
+      lon: 7.16806189486532,
+      children: [],
+      locationType: 'SIMPLE_STOP_OR_PLATFORM',
+    },
+  ],
+  [
+    'Parent8504100',
+    {
+      id: 'Parent8504100',
+      name: 'Fribourg/Freiburg',
+      lat: 46.8031492395272,
+      lon: 7.15104780338173,
+      children: ['8504100:0:1', '8504100:0:1AB', '8504100:0:2'],
+      locationType: 'STATION',
+    },
+  ],
+  [
+    '8504100:0:1',
+    {
+      id: '8504100:0:1',
+      name: 'Fribourg/Freiburg',
+      lat: 46.8031492395272,
+      lon: 7.15104780338173,
+      children: [],
+      locationType: 'SIMPLE_STOP_OR_PLATFORM',
+      parent: 'Parent8504100',
+    },
+  ],
+  [
+    '8504100:0:1AB',
+    {
+      id: '8504100:0:1AB',
+      name: 'Fribourg/Freiburg',
+      lat: 46.8031492395272,
+      lon: 7.15104780338173,
+      children: [],
+      locationType: 'SIMPLE_STOP_OR_PLATFORM',
+      parent: 'Parent8504100',
+    },
+  ],
+  [
+    '8504100:0:2',
+    {
+      id: '8504100:0:2',
+      name: 'Fribourg/Freiburg',
+      lat: 46.8031492395272,
+      lon: 7.15104780338173,
+      children: [],
+      locationType: 'SIMPLE_STOP_OR_PLATFORM',
+      parent: 'Parent8504100',
+    },
+  ],
+]);
+
+describe('StopFinder', () => {
+  let stopFinder: StopsIndex;
+
+  beforeEach(() => {
+    stopFinder = new StopsIndex(mockStops);
+  });
+
+  describe('findStopsByName', () => {
+    it('should find stops by exact name', () => {
+      const results = stopFinder.findStopsByName(
+        'Fribourg, Tilleul/Cathédrale',
+      );
+      assert.strictEqual(results[0]?.id, '8587255');
+    });
+
+    it('should not include children stops', () => {
+      const results = stopFinder.findStopsByName('Fribourg/Freiburg', 2);
+      assert.strictEqual(results[0]?.id, 'Parent8504100');
+      assert.strictEqual(results[1]?.id, '8587255');
+    });
+
+    it('should find stops by partial name', () => {
+      const results = stopFinder.findStopsByName('Cathédrale');
+      assert.strictEqual(results.length, 1);
+      assert.strictEqual(results[0]?.id, '8587255');
+    });
+
+    it('should find stops by name with accents', () => {
+      const results = stopFinder.findStopsByName('Cathedrale');
+      assert.strictEqual(results.length, 1);
+      assert.strictEqual(results[0]?.id, '8587255');
+    });
+
+    it('should return an empty array if no stops match the query', () => {
+      const results = stopFinder.findStopsByName('Nonexistent Stop');
+      assert.strictEqual(results.length, 0);
+    });
+  });
+
+  describe('findStopsByLocation', () => {
+    it('should find stops by geographic location', () => {
+      const results = stopFinder.findStopsByLocation(46.8061, 7.1614, 1);
+      assert.strictEqual(results.length, 1);
+      assert.strictEqual(results[0]?.id, '8587255');
+    });
+
+    it('should find multiple stops within the radius', () => {
+      const results = stopFinder.findStopsByLocation(46.8, 7.16, 10, 0.75);
+      assert.strictEqual(results.length, 3);
+      assert.strictEqual(results[0]?.id, '8592383');
+      assert.strictEqual(results[1]?.id, '8587255');
+      assert.strictEqual(results[2]?.id, '8592386');
+    });
+
+    it('should find the N closest stops', () => {
+      const results = stopFinder.findStopsByLocation(46.8, 7.16, 2, 10);
+      assert.strictEqual(results.length, 2);
+      assert.strictEqual(results[0]?.id, '8592383');
+      assert.strictEqual(results[1]?.id, '8587255');
+    });
+
+    it('should return an empty array if no stops are within the radius', () => {
+      const results = stopFinder.findStopsByLocation(0, 0);
+      assert.strictEqual(results.length, 0);
+    });
+  });
+
+  describe('fromData', () => {
+    it('should deserialize stops data and create a StopFinder instance', () => {
+      const serializedData = stopFinder.serialize();
+      const deserializedStopFinder = StopsIndex.fromData(serializedData);
+      const results = deserializedStopFinder.findStopsByName('Fribourg');
+      assert.strictEqual(results.length, 4);
+    });
+  });
+
+  describe('equivalentStops', () => {
+    it('should find equivalent stops for a given stop ID', () => {
+      const equivalentStops = stopFinder.equivalentStops('8504100:0:1');
+      assert.deepStrictEqual(equivalentStops, [
+        '8504100:0:1',
+        '8504100:0:1AB',
+        '8504100:0:2',
+      ]);
+    });
+
+    it('should return the same stop ID in an array if no equivalents', () => {
+      const equivalentStops = stopFinder.equivalentStops('8587255');
+      assert.deepStrictEqual(equivalentStops, ['8587255']);
+    });
+
+    it('should return an empty array for non-existent stop ID', () => {
+      const equivalentStops = stopFinder.equivalentStops('nonexistent');
+      assert.deepStrictEqual(equivalentStops, []);
+    });
+  });
+});

package/src/stops/i18n.ts

@@ -0,0 +1,40 @@
+/**
+ * Generates a list of accent variants for a given term.
+ *
+ * This function takes a term and generates a list of alternative spellings
+ * by replacing characters with their accented variants and vice versa.
+ *
+ * @param term - The input term for which to generate accent variants.
+ * @returns An array of strings containing the original term and its accent variants.
+ */
+export const generateAccentVariants = (term: string): string[] => {
+  const lowerCaseTerm = term.toLowerCase();
+  const alternatives = new Set([lowerCaseTerm]);
+
+  const accentMap: { [key: string]: string[] } = {
+    a: ['à', 'â', 'ä'],
+    c: ['ç'],
+    e: ['é', 'è', 'ê', 'ë'],
+    i: ['î', 'ï'],
+    o: ['ô', 'ö'],
+    u: ['ù', 'û', 'ü'],
+    ae: ['ä'],
+    oe: ['ö'],
+    ue: ['ü'],
+  };
+
+  for (const [base, accents] of Object.entries(accentMap)) {
+    if (lowerCaseTerm.includes(base)) {
+      accents.forEach((accent) => {
+        alternatives.add(lowerCaseTerm.replace(base, accent));
+      });
+    }
+    accents.forEach((accent) => {
+      if (lowerCaseTerm.includes(accent)) {
+        alternatives.add(lowerCaseTerm.replace(accent, base));
+      }
+    });
+  }
+
+  return Array.from(alternatives);
+};

package/src/stops/io.ts

@@ -0,0 +1,94 @@
+import {
+  LocationType as ProtoLocationType,
+  Stop as ProtoStop,
+  StopsMap as ProtoStopsMap,
+} from './proto/stops.js';
+import { LocationType, Stop, StopId, StopsMap } from './stops.js';
+
+const CURRENT_VERSION = '0.0.1';
+const serializeStop = (stop: Stop): ProtoStop => {
+  return {
+    name: stop.name,
+    lat: stop.lat,
+    lon: stop.lon,
+    children: stop.children,
+    parent: stop.parent,
+    locationType: serializeLocationType(stop.locationType),
+    platform: stop.platform,
+  };
+};
+
+export const serializeStopsMap = (stopsMap: StopsMap): ProtoStopsMap => {
+  const protoStopsMap: ProtoStopsMap = {
+    version: CURRENT_VERSION,
+    stops: {},
+  };
+
+  stopsMap.forEach((value: Stop, key: string) => {
+    protoStopsMap.stops[key] = serializeStop(value);
+  });
+
+  return protoStopsMap;
+};
+
+const deserializeStop = (stopId: StopId, protoStop: ProtoStop): Stop => {
+  return {
+    id: stopId,
+    name: protoStop.name,
+    lat: protoStop.lat,
+    lon: protoStop.lon,
+    children: protoStop.children,
+    parent: protoStop.parent,
+    locationType: parseProtoLocationType(protoStop.locationType),
+    platform: protoStop.platform,
+  };
+};
+
+export const deserializeStopsMap = (protoStopsMap: ProtoStopsMap): StopsMap => {
+  if (protoStopsMap.version !== CURRENT_VERSION) {
+    throw new Error(`Unsupported stopMap version ${protoStopsMap.version}`);
+  }
+  const stopsMap: StopsMap = new Map();
+
+  Object.entries(protoStopsMap.stops).forEach(([key, value]) => {
+    stopsMap.set(key, deserializeStop(key, value));
+  });
+
+  return stopsMap;
+};
+
+const parseProtoLocationType = (
+  protoLocationType: ProtoLocationType,
+): LocationType => {
+  switch (protoLocationType) {
+    case ProtoLocationType.SIMPLE_STOP_OR_PLATFORM:
+      return 'SIMPLE_STOP_OR_PLATFORM';
+    case ProtoLocationType.STATION:
+      return 'STATION';
+    case ProtoLocationType.ENTRANCE_EXIT:
+      return 'ENTRANCE_EXIT';
+    case ProtoLocationType.GENERIC_NODE:
+      return 'GENERIC_NODE';
+    case ProtoLocationType.BOARDING_AREA:
+      return 'BOARDING_AREA';
+    case ProtoLocationType.UNRECOGNIZED:
+      throw new Error('Unrecognized protobuf location type.');
+  }
+};
+
+const serializeLocationType = (
+  locationType: LocationType,
+): ProtoLocationType => {
+  switch (locationType) {
+    case 'SIMPLE_STOP_OR_PLATFORM':
+      return ProtoLocationType.SIMPLE_STOP_OR_PLATFORM;
+    case 'STATION':
+      return ProtoLocationType.STATION;
+    case 'ENTRANCE_EXIT':
+      return ProtoLocationType.ENTRANCE_EXIT;
+    case 'GENERIC_NODE':
+      return ProtoLocationType.GENERIC_NODE;
+    case 'BOARDING_AREA':
+      return ProtoLocationType.BOARDING_AREA;
+  }
+};

package/src/stops/proto/stops.proto

@@ -0,0 +1,26 @@
+syntax = "proto3";
+
+package minotor.stops;
+
+enum LocationType {
+  SIMPLE_STOP_OR_PLATFORM = 0;
+  STATION = 1;
+  ENTRANCE_EXIT = 2;
+  GENERIC_NODE = 3;
+  BOARDING_AREA = 4;
+}
+
+message Stop {
+  string name = 1;
+  optional double lat = 2;
+  optional double lon = 3;
+  repeated string children = 4;
+  optional string parent = 5;
+  LocationType locationType = 6;
+  optional string platform = 7;
+}
+
+message StopsMap {
+  string version = 1;
+  map<string, Stop> stops = 2;
+}