@madebylars.com/mbl-fleetmap 1.0.0

package/dist/runtime/composables/useFleetRoute.js

@@ -0,0 +1,28 @@
+import { ref } from "vue";
+import { getMap, getLeaflet } from "../utils/registry.js";
+export function useFleetRoute(mapId) {
+  const routes = ref(/* @__PURE__ */ new Map());
+  const drawRoute = (jobId, waypoints) => {
+    const L = getLeaflet();
+    const map = getMap(mapId);
+    if (!L || !map) return;
+    clearRoute(jobId);
+    const polyline = L.polyline(waypoints, {
+      color: "#2563eb",
+      weight: 4,
+      opacity: 0.8
+    }).addTo(map);
+    routes.value.set(jobId, polyline);
+  };
+  const clearRoute = (jobId) => {
+    const route = routes.value.get(jobId);
+    if (!route) return;
+    route.remove();
+    routes.value.delete(jobId);
+  };
+  const clearAll = () => {
+    routes.value.forEach((route) => route.remove());
+    routes.value.clear();
+  };
+  return { drawRoute, clearRoute, clearAll, routes };
+}

package/dist/runtime/composables/useJobPins.d.ts

@@ -0,0 +1,6 @@
+export declare function useJobPins(mapId: string): {
+    setPickup: (jobId: string, lat: number, lng: number, label?: string) => void;
+    setDropoff: (jobId: string, lat: number, lng: number, label?: string) => void;
+    clearJob: (jobId: string) => void;
+    clearAll: () => void;
+};

package/dist/runtime/composables/useJobPins.js

@@ -0,0 +1,62 @@
+import { getMap, getLeaflet } from "../utils/registry.js";
+const PIN_COLORS = {
+  pickup: "#16a34a",
+  dropoff: "#dc2626"
+};
+function createPinIcon(L, type) {
+  const color = PIN_COLORS[type];
+  return L.divIcon({
+    className: "",
+    html: `<div style="position:relative;width:24px;height:36px;">
+      <div style="
+        position:absolute;top:0;left:0;
+        width:24px;height:24px;
+        border-radius:50% 50% 50% 0;
+        background:${color};
+        transform:rotate(-45deg);
+        box-shadow:0 2px 4px rgba(0,0,0,.3);
+      "></div>
+      <div style="
+        position:absolute;top:4px;left:4px;
+        width:16px;height:16px;
+        border-radius:50%;
+        background:#fff;
+      "></div>
+    </div>`,
+    iconSize: [24, 36],
+    iconAnchor: [12, 36],
+    tooltipAnchor: [12, -36]
+  });
+}
+export function useJobPins(mapId) {
+  const pinInstances = /* @__PURE__ */ new Map();
+  function upsertPin(type, jobId, lat, lng, label) {
+    const L = getLeaflet();
+    const map = getMap(mapId);
+    if (!L || !map) return;
+    const pair = pinInstances.get(jobId) ?? {};
+    pair[type]?.remove();
+    const marker = L.marker([lat, lng], { icon: createPinIcon(L, type) }).addTo(map);
+    const tooltipText = label ?? (type === "pickup" ? "Pickup" : "Dropoff");
+    marker.bindTooltip(tooltipText, { permanent: false, direction: "top" });
+    pair[type] = marker;
+    pinInstances.set(jobId, pair);
+  }
+  const setPickup = (jobId, lat, lng, label) => upsertPin("pickup", jobId, lat, lng, label);
+  const setDropoff = (jobId, lat, lng, label) => upsertPin("dropoff", jobId, lat, lng, label);
+  const clearJob = (jobId) => {
+    const pair = pinInstances.get(jobId);
+    if (!pair) return;
+    pair.pickup?.remove();
+    pair.dropoff?.remove();
+    pinInstances.delete(jobId);
+  };
+  const clearAll = () => {
+    pinInstances.forEach((pair) => {
+      pair.pickup?.remove();
+      pair.dropoff?.remove();
+    });
+    pinInstances.clear();
+  };
+  return { setPickup, setDropoff, clearJob, clearAll };
+}

package/dist/runtime/composables/useMapEvents.d.ts

@@ -0,0 +1,7 @@
+import type { DriverMarker } from '../../types.js';
+export declare function useMapEvents(mapId: string): {
+    onDriverClick: (handler: (driver: DriverMarker) => void) => void;
+    onMapClick: (handler: (lat: number, lng: number) => void) => void;
+    onDriverHover: (handler: (driver: DriverMarker | null) => void) => void;
+    offAll: () => void;
+};

package/dist/runtime/composables/useMapEvents.js

@@ -0,0 +1,19 @@
+import {
+  addDriverClickHandler,
+  addMapClickHandler,
+  addDriverHoverHandler,
+  clearBus
+} from "../utils/events.js";
+export function useMapEvents(mapId) {
+  const onDriverClick = (handler) => {
+    addDriverClickHandler(mapId, handler);
+  };
+  const onMapClick = (handler) => {
+    addMapClickHandler(mapId, ({ lat, lng }) => handler(lat, lng));
+  };
+  const onDriverHover = (handler) => {
+    addDriverHoverHandler(mapId, handler);
+  };
+  const offAll = () => clearBus(mapId);
+  return { onDriverClick, onMapClick, onDriverHover, offAll };
+}

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,7 @@
+import { defineNuxtPlugin } from "#app";
+import { setLeaflet } from "./utils/registry.js";
+export default defineNuxtPlugin(async () => {
+  if (import.meta.server) return;
+  const L = await import("leaflet");
+  setLeaflet(L);
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/utils/events.d.ts

@@ -0,0 +1,19 @@
+import type { DriverMarker } from '../../types.js';
+type Handler<T> = (payload: T) => void;
+export declare const emitDriverClick: (mapId: string, driver: DriverMarker) => void;
+export declare const emitMapClick: (mapId: string, payload: {
+    lat: number;
+    lng: number;
+}) => void;
+export declare const emitDriverHover: (mapId: string, driver: DriverMarker | null) => void;
+export declare const addDriverClickHandler: (mapId: string, handler: Handler<DriverMarker>) => Set<Handler<DriverMarker>>;
+export declare const addMapClickHandler: (mapId: string, handler: Handler<{
+    lat: number;
+    lng: number;
+}>) => Set<Handler<{
+    lat: number;
+    lng: number;
+}>>;
+export declare const addDriverHoverHandler: (mapId: string, handler: Handler<DriverMarker | null>) => Set<Handler<DriverMarker | null>>;
+export declare const clearBus: (mapId: string) => void;
+export {};

package/dist/runtime/utils/events.js

@@ -0,0 +1,24 @@
+const busRegistry = /* @__PURE__ */ new Map();
+function getBus(mapId) {
+  if (!busRegistry.has(mapId)) {
+    busRegistry.set(mapId, {
+      driverClick: /* @__PURE__ */ new Set(),
+      mapClick: /* @__PURE__ */ new Set(),
+      driverHover: /* @__PURE__ */ new Set()
+    });
+  }
+  return busRegistry.get(mapId);
+}
+export const emitDriverClick = (mapId, driver) => getBus(mapId).driverClick.forEach((h) => h(driver));
+export const emitMapClick = (mapId, payload) => getBus(mapId).mapClick.forEach((h) => h(payload));
+export const emitDriverHover = (mapId, driver) => getBus(mapId).driverHover.forEach((h) => h(driver));
+export const addDriverClickHandler = (mapId, handler) => getBus(mapId).driverClick.add(handler);
+export const addMapClickHandler = (mapId, handler) => getBus(mapId).mapClick.add(handler);
+export const addDriverHoverHandler = (mapId, handler) => getBus(mapId).driverHover.add(handler);
+export const clearBus = (mapId) => {
+  const bus = busRegistry.get(mapId);
+  if (!bus) return;
+  bus.driverClick.clear();
+  bus.mapClick.clear();
+  bus.driverHover.clear();
+};

package/dist/runtime/utils/registry.d.ts

@@ -0,0 +1,6 @@
+import type L from 'leaflet';
+export declare const registerMap: (id: string, map: L.Map) => import("vue").ShallowReactive<Map<string, L.Map>>;
+export declare const getMap: (id: string) => L.Map | null;
+export declare const removeMap: (id: string) => boolean;
+export declare const setLeaflet: (L: unknown) => void;
+export declare const getLeaflet: () => typeof import("leaflet") | null;

package/dist/runtime/utils/registry.js

@@ -0,0 +1,10 @@
+import { shallowReactive } from "vue";
+const mapRegistry = shallowReactive(/* @__PURE__ */ new Map());
+export const registerMap = (id, map) => mapRegistry.set(id, map);
+export const getMap = (id) => mapRegistry.get(id) ?? null;
+export const removeMap = (id) => mapRegistry.delete(id);
+let _leaflet = null;
+export const setLeaflet = (L) => {
+  _leaflet = L;
+};
+export const getLeaflet = () => _leaflet;

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@madebylars.com/mbl-fleetmap",
+  "version": "1.0.0",
+  "description": "Nuxt 4 module — Leaflet-powered transport map with driver markers and route API",
+  "repository": "madebylars/mbl-fleetmap",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.4.7",
+    "@vue-leaflet/vue-leaflet": "^0.10.1",
+    "leaflet": "^1.9.4"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.2.4",
+    "@nuxt/eslint-config": "^1.15.2",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.7",
+    "@nuxt/test-utils": "^4.0.3",
+    "@types/leaflet": "^1.9.21",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.4.1",
+    "nuxt": "^4.4.7",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.8",
+    "vue-tsc": "^3.3.3"
+  },
+  "peerDependencies": {
+    "nuxt": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}