@any-routing/core 0.1.0 → 1.0.0-rc.2

package/README.md

@@ -2,6 +2,10 @@
 
 This library was generated with [Nx](https://nx.dev).
 
+## Building
+
+Run `nx build core` to build the library.
+
 ## Running unit tests
 
-Run `nx test core` to execute the unit tests via [Jest](https://jestjs.io).
+Run `nx test core` to execute the unit tests via [Vitest](https://vitest.dev/).

package/eslint.config.mjs

@@ -0,0 +1,24 @@
+import baseConfig from "../../eslint.config.mjs";
+
+export default [
+    ...baseConfig,
+    {
+        files: [
+            "**/*.json"
+        ],
+        rules: {
+      "@nx/dependency-checks": [
+        "error",
+        {
+          "ignoredFiles": [
+            "{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}",
+            "{projectRoot}/vite.config.{js,ts,mjs,mts}"
+          ]
+        }
+      ]
+    },
+        languageOptions: {
+            parser: await import("jsonc-eslint-parser")
+        }
+    }
+];

package/package.json

@@ -1,31 +1,10 @@
 {
   "name": "@any-routing/core",
-  "version": "0.1.0",
-  "private": false,
-  "license": "MIT",
-  "author": "Marcin Lazar",
-  "keywords": [
-    "MapLibre GL",
-    "Routing",
-    "Directions",
-    "Route",
-    "OSMR",
-    "Here",
-    "Plugin",
-    "Map",
-    "js",
-    "leaflet"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/marucjmar/any-routing"
-  },
+  "version": "1.0.0-rc.2",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
   "dependencies": {
-    "@turf/helpers": "6.5.0"
-  },
-  "peerDependencies": {
-    "tslib": "2.5.0"
-  },
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts"
-}
+    "@types/geojson": "7946.0.16"
+  }
+}

package/project.json

@@ -0,0 +1,21 @@
+{
+  "name": "core",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/core/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "manifestRootsToUpdate": ["dist/{projectRoot}"],
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk"
+    }
+  },
+  "tags": [],
+  "targets": {
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './lib/core';
+export * from './lib/data-providers';
+export * from './lib/core.model';
+export * from './lib/utils';

package/src/lib/core.model.ts

@@ -0,0 +1,209 @@
+import { AnyRoutingDataProvider, AnyRoutingDataResponse, RouteSummary } from './data-providers';
+import type { AnyRouting } from './core';
+
+export type LngLatPosition = number[];
+
+export type WaypointPosition = { lat: number; lng: number };
+
+export type RoutingEventPayloads<R extends AnyRoutingDataResponse> = {
+  calculationStarted: {
+    waypoints: InternalWaypoint[];
+  };
+
+  calculationError: {
+    error: Error;
+  };
+
+  routesFound: {
+    waypoints: InternalWaypoint[];
+    data: R;
+  };
+
+  routeSelected: {
+    routeId: number;
+    route: RouteSummary;
+  };
+
+  waypointsChanged: {
+    waypoints: InternalWaypoint[];
+  };
+
+  waypointGeocoded: {
+    waypoint: InternalWaypoint;
+  };
+
+  loadingChanged: {
+    loading: boolean;
+  };
+
+  stateUpdated: {
+    updatedProperties: Array<keyof AnyRoutingState<R>>;
+  };
+};
+
+export type RoutingEvent<
+  R extends AnyRoutingDataResponse,
+  E extends keyof RoutingEventPayloads<R>
+> = RoutingEventPayloads<R>[E] & {
+  state: AnyRoutingState<R>;
+  eventName: E;
+};
+
+export type RoutingEvents<R extends AnyRoutingDataResponse> = {
+  calculationStarted: {
+    state: AnyRoutingState<R>;
+    waypoints: InternalWaypoint[];
+  };
+
+  calculationError: {
+    state: AnyRoutingState<R>;
+    error: Error;
+  };
+
+  routesFound: {
+    state: AnyRoutingState<R>;
+    waypoints: InternalWaypoint[];
+    data: R;
+  };
+
+  routeSelected: {
+    state: AnyRoutingState<R>;
+    routeId: number;
+    route: RouteSummary;
+  };
+
+  waypointsChanged: {
+    state: AnyRoutingState<R>;
+    waypoints: InternalWaypoint[];
+  };
+
+  waypointGeocoded: {
+    state: AnyRoutingState<R>;
+    waypoint: InternalWaypoint;
+  };
+
+  loadingChanged: {
+    state: AnyRoutingState<R>;
+    loading: boolean;
+  };
+
+  stateUpdated: {
+    state: AnyRoutingState<R>;
+    updatedProperties: Array<keyof AnyRoutingState<R>>;
+  };
+};
+
+
+export type InternalWaypointProperties = {
+  index: number;
+  isFirst: boolean;
+  isLast: boolean;
+};
+
+export type AnyRoutingState<DataType = AnyRoutingDataResponse> = {
+  data: DataType | undefined;
+  waypoints: InternalWaypoint[];
+  loading: boolean;
+  selectedRouteId: number | undefined | null;
+  routesShapeGeojson?: AnyRoutingDataResponse['routesShapeGeojson'];
+};
+
+export interface InternalWaypoint {
+  index: number;
+  position: WaypointPosition;
+  originalPosition: WaypointPosition;
+  properties: InternalWaypointProperties & Record<string, string | boolean | number>;
+  geocoded?: boolean;
+}
+
+export function isWaypointPositionEqual(posA: WaypointPosition, posB: WaypointPosition): boolean {
+  return posA.lat === posB.lat && posA.lng === posB.lng;
+}
+
+export class InternalWaypointC {
+  public static fromWaypoint(waypoint: Waypoint, props: InternalWaypointProperties): InternalWaypoint {
+    return {
+      index: props.index,
+      originalPosition: waypoint.position,
+      position: waypoint.position,
+      geocoded: waypoint.geocoded,
+      properties: { ...props, ...(waypoint.properties || {}) },
+    };
+  }
+}
+
+export interface Waypoint {
+  position: WaypointPosition;
+  originalPosition?: WaypointPosition;
+  properties?: Record<string, string | boolean | number>;
+  geocoded?: boolean;
+}
+
+export type PluginFactory = AnyRoutingPlugin | (new (...args: any[]) => AnyRoutingPlugin);
+
+export interface AnyRoutingGeocoder {
+  geocode(waypoint: InternalWaypoint): Promise<InternalWaypoint>;
+}
+
+export type AnyRoutingProjectorEventMap = {
+  previewStarted: Record<string, never>;
+  previewFinished: { data: AnyRoutingDataResponse };
+  previewError: { error: Error };
+  waypointDrag: {
+    waypoint: InternalWaypoint;
+  };
+  waypointDragCommit: {
+    waypoint: InternalWaypoint;
+  };
+  waypointDragEnd: {
+    waypoint: InternalWaypoint;
+  };
+  waypointAdded: {
+    waypoint: InternalWaypoint;
+  };
+  routesProjected: {
+    routesShapeGeojson: AnyRoutingDataResponse['routesShapeGeojson'];
+  };
+  waypointsProjected: {
+    waypoints: InternalWaypoint[];
+  };
+  routeClick: {
+    routeId: number;
+  };
+  routeHighlight: {
+    routeId?: number;
+  };
+  viewStateChanged: {
+    state: AnyRoutingState;
+    reason: 'route' | 'waypoints' | 'interaction';
+  };
+};
+
+export interface AnyRoutingProjector {
+  waypoints: InternalWaypoint[];
+  onAdd(routing: AnyRouting<any>): void;
+  onRemove(routing: AnyRouting<any>): void;
+  highlightRoute?(routeId?: number): void;
+  on<E extends keyof AnyRoutingProjectorEventMap>(
+    event: E,
+    callback: (event: AnyRoutingProjectorEventMap[E]) => void,
+  ): void;
+  off<E extends keyof AnyRoutingProjectorEventMap>(
+    event: E,
+    callback: (event: AnyRoutingProjectorEventMap[E]) => void,
+  ): void;
+}
+
+export type AnyRoutingOptions<P extends AnyRoutingProjector = AnyRoutingProjector> = {
+  dataProvider: AnyRoutingDataProvider;
+  projector?: P;
+  geocoder?: AnyRoutingGeocoder | ((waypoint: InternalWaypoint) => Promise<InternalWaypoint>);
+  plugins?: PluginFactory[];
+  uniqueKey?: string;
+  waypointsSyncStrategy: 'none' | 'toPath' | 'geocodeFirst';
+};
+
+export interface AnyRoutingPlugin {
+  onAdd(AnyRouting: AnyRouting<any>): void;
+  onRemove(AnyRouting: AnyRouting<any>): void;
+}