@any-routing/leaflet-engine 1.0.0-rc.1

package/src/lib/projector.leaflet.plugin.types.ts

@@ -0,0 +1,137 @@
+import type {
+  AnyRouting,
+  AnyRoutingDataProvider,
+  AnyRoutingDataResponse,
+  AnyRoutingProjectorEventMap,
+  InternalWaypoint,
+} from '@any-routing/core';
+import type { Feature, Geometry } from 'geojson';
+import type { LatLngExpression, Layer, LeafletMouseEvent, Map, Marker } from 'leaflet';
+
+export type WaypointDragEvent = {
+  waypoint: InternalWaypoint;
+};
+
+export type RouteClickEvent = {
+  routeId: number;
+};
+
+export type RoutesProjectedEvent = {
+  routesShapeGeojson: AnyRoutingDataResponse['routesShapeGeojson'];
+};
+
+export type WaypointsProjectedEvent = {
+  waypoints: InternalWaypoint[];
+};
+
+export type WaypointDragEndEvent = {
+  waypoint: InternalWaypoint;
+};
+
+export type WaypointAddedEvent = {
+  waypoint: InternalWaypoint;
+};
+
+export interface LeafletProjectorEventMap {
+  previewStarted: Record<string, never>;
+  previewFinished: { data: AnyRoutingDataResponse };
+  previewError: { error: Error };
+  waypointDrag: WaypointDragEvent;
+  waypointDragCommit: WaypointDragEvent;
+  waypointDragEnd: WaypointDragEndEvent;
+  waypointAdded: WaypointAddedEvent;
+  routesProjected: RoutesProjectedEvent;
+  waypointsProjected: WaypointsProjectedEvent;
+  routeClick: RouteClickEvent;
+  routeHighlight: AnyRoutingProjectorEventMap['routeHighlight'];
+  viewStateChanged: AnyRoutingProjectorEventMap['viewStateChanged'];
+}
+
+export type MarkerFactoryContext = {
+  waypoint?: InternalWaypoint;
+  routeHover?: Feature<Geometry, RouteFeatureProperties>;
+};
+
+export type LeafletMarkerFactory = (
+  ctx: MarkerFactoryContext,
+) => Marker;
+
+export type LeafletProjectorOptions = {
+  map: Map;
+
+  editable?: boolean;
+
+  maxWaypoints?: number;
+
+  canAddWaypoints?: boolean;
+
+  canDragWaypoints?: boolean;
+
+  canSelectRoute?: boolean;
+
+  hoverEnabled?: boolean;
+
+  routesWhileDragging?: boolean;
+
+  waypointDragCommitDebounceTime?: number;
+
+  previewDataProvider?: AnyRoutingDataProvider;
+
+  markerFactory: LeafletMarkerFactory;
+
+  /**
+   * Optional custom route style.
+   */
+  routeStyle?: LeafletRouteStyle;
+
+  /**
+   * Optional selected route style.
+   */
+  selectedRouteStyle?: LeafletRouteStyle;
+
+  /**
+   * Optional style for the route casing rendered underneath each route.
+   */
+  routeOutlineStyle?: LeafletRouteStyle;
+
+  /**
+   * Optional z-index for selected routes.
+   */
+  selectedRouteZIndex?: number;
+
+  /**
+   * Optional z-index for regular routes.
+   */
+  routeZIndex?: number;
+};
+
+export type LeafletRouteStyle = {
+  color?: string;
+
+  weight?: number;
+
+  opacity?: number;
+
+  dashArray?: string;
+
+  lineCap?: 'butt' | 'round' | 'square';
+
+  lineJoin?: 'miter' | 'round' | 'bevel';
+
+  className?: string;
+};
+
+export type RouteFeatureProperties = {
+  routeId: number;
+
+  waypoint: number;
+
+  selected?: boolean;
+
+  offset?: number;
+};
+
+export type LeafletRouteFeature = Feature<
+  Geometry,
+  RouteFeatureProperties
+>;

package/src/lib/utils/debounce.util.ts

@@ -0,0 +1,164 @@
+type DebounceOptions = {
+  leading?: boolean;
+  maxWait?: number;
+  trailing?: boolean;
+};
+
+type DebouncedFunction<T extends (...args: any[]) => any> = ((
+  ...args: Parameters<T>
+) => ReturnType<T> | undefined) & {
+  cancel: () => void;
+  flush: () => ReturnType<T> | undefined;
+};
+
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait = 0,
+  options: DebounceOptions = {},
+): DebouncedFunction<T> {
+  if (typeof func !== 'function') {
+    throw new TypeError('Expected a function');
+  }
+
+  const delay = Number(wait) || 0;
+
+  const leading = options.leading ?? false;
+  const trailing = options.trailing ?? true;
+  const maxing = options.maxWait !== undefined;
+  const maxWait = maxing
+    ? Math.max(Number(options.maxWait) || 0, delay)
+    : undefined;
+
+  let lastArgs: Parameters<T> | undefined;
+  let lastThis: ThisParameterType<T> | undefined;
+
+  let timerId: ReturnType<typeof setTimeout> | undefined;
+  let lastCallTime: number | undefined;
+  let lastInvokeTime = 0;
+
+  let result: ReturnType<T> | undefined;
+
+  const invoke = (time: number): ReturnType<T> | undefined => {
+    const args = lastArgs!;
+    const thisArg = lastThis;
+
+    lastArgs = undefined;
+    lastThis = undefined;
+    lastInvokeTime = time;
+
+    result = func.apply(thisArg, args);
+
+    return result;
+  };
+
+  const startTimer = (time: number): void => {
+    timerId = setTimeout(timerExpired, time);
+  };
+
+  const leadingEdge = (time: number): ReturnType<T> | undefined => {
+    lastInvokeTime = time;
+    startTimer(delay);
+
+    return leading ? invoke(time) : result;
+  };
+
+  const remainingWait = (time: number): number => {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+
+    const remaining = delay - timeSinceLastCall;
+
+    return maxing
+      ? Math.min(remaining, maxWait! - timeSinceLastInvoke)
+      : remaining;
+  };
+
+  const shouldInvoke = (time: number): boolean => {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+
+    return (
+      lastCallTime === undefined ||
+      timeSinceLastCall >= delay ||
+      timeSinceLastCall < 0 ||
+      (maxing && timeSinceLastInvoke >= maxWait!)
+    );
+  };
+
+  const trailingEdge = (time: number): ReturnType<T> | undefined => {
+    timerId = undefined;
+
+    if (trailing && lastArgs) {
+      return invoke(time);
+    }
+
+    lastArgs = undefined;
+    lastThis = undefined;
+
+    return result;
+  };
+
+  const timerExpired = (): void => {
+    const time = Date.now();
+
+    if (shouldInvoke(time)) {
+      trailingEdge(time);
+      return;
+    }
+
+    startTimer(remainingWait(time));
+  };
+
+  const cancel = (): void => {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+
+    lastInvokeTime = 0;
+    lastArgs = undefined;
+    lastThis = undefined;
+    lastCallTime = undefined;
+    timerId = undefined;
+  };
+
+  const flush = (): ReturnType<T> | undefined => {
+    return timerId === undefined
+      ? result
+      : trailingEdge(Date.now());
+  };
+
+  const debounced = function (
+    this: ThisParameterType<T>,
+    ...args: Parameters<T>
+  ): ReturnType<T> | undefined {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+
+    lastArgs = args;
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(time);
+      }
+
+      if (maxing) {
+        startTimer(delay);
+        return invoke(time);
+      }
+    }
+
+    if (timerId === undefined) {
+      startTimer(delay);
+    }
+
+    return result;
+  } as DebouncedFunction<T>;
+
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+
+  return debounced;
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node", "vite/client"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,22 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../../dist/out-tsc",
+    "types": ["vitest/globals", "vitest/importMeta", "vite/client", "node", "vitest"]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/vite.config.mts

@@ -0,0 +1,59 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+import * as path from 'path';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: import.meta.dirname,
+  cacheDir: '../../../../node_modules/.vite/libs/line-loader/libs/leaflet-engine',
+  plugins: [
+    nxViteTsPaths(),
+    nxCopyAssetsPlugin(['*.md']),
+    dts({
+      entryRoot: 'src',
+      tsconfigPath: path.join(import.meta.dirname, 'tsconfig.lib.json'),
+      pathsToAliases: false,
+    }),
+  ],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  // Configuration for building your library.
+  // See: https://vite.dev/guide/build.html#library-mode
+  build: {
+    outDir: '../../dist/libs/line-loader/libs/leaflet-engine',
+    emptyOutDir: true,
+    reportCompressedSize: true,
+    commonjsOptions: {
+      transformMixedEsModules: true,
+    },
+    lib: {
+      // Could also be a dictionary or array of multiple entry points.
+      entry: 'src/index.ts',
+      name: 'leaflet-engine',
+      fileName: 'index',
+      // Change this to the formats you want to support.
+      // Don't forget to update your package.json as well.
+      formats: ['es' as const],
+    },
+    rolldownOptions: {
+      // External packages that should not be bundled into your library.
+      external: [],
+    },
+  },
+  test: {
+    name: 'leaflet-engine',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../../../coverage/libs/line-loader/libs/leaflet-engine',
+      provider: 'v8' as const,
+    },
+  },
+}));