@osm-editor-kit/osm-coverage 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,36 @@
+# `@osm-editor-kit/osm-coverage`
+
+**Status:** First npm **alpha** (`0.1.0-alpha.0`). Publish with `bun run packages:release -- --publish-only` after `npm login`.
+
+## What it does
+
+TanStack Query–backed OSM viewport coverage for map editors: incremental downloads, merged `ParsedOsmData` graphs, coverage polygons, and fetch-history GeoJSON. Includes zoom-aware missing-area detection (`computeMissingFetchRequests`, `unionIntoCoverage`), Overpass URL helpers (`boundsToOverpassBbox`, `buildOverpassInterpreterUrl`, `overpassDeUrl`, `overpassVkUrl`), and an `OsmDataSource` enum for download backends.
+
+The `@osm-editor-kit/osm-coverage/dev-osm-map-fixture` subpath is **editor-dev only** — local OSM Map API fixture handler, bbox filtering, and fixture index loader.
+
+## Usage
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+import { createOsmCoverageApi, OsmDataSource } from '@osm-editor-kit/osm-coverage'
+
+const api = createOsmCoverageApi<{ source: OsmDataSource }>({
+  getSessionKey: ({ source }) => ['osm', source] as const,
+  minZoom: 14,
+  getDownloadUrl: (bounds, { source }) =>
+  /* build Overpass or Map API URL */ '',
+})
+
+const queryClient = new QueryClient()
+const params = { source: OsmDataSource.OverpassVk }
+
+await api.ensureCoverage(queryClient, {
+  bounds: { south: 52.47, west: 13.44, north: 52.48, east: 13.45 },
+  zoom: 18,
+  mapSizePx: { width: 1024, height: 768 },
+  ...params,
+})
+
+const data = queryClient.getQueryData(api.sessionKey(params))
+// { graph, coverage, fetchHistory }
+```

package/dist/coverage-geometry.d.ts

@@ -0,0 +1,38 @@
+import type { MapBounds } from '@osm-editor-kit/osm-data';
+import type { Feature, FeatureCollection, MultiPolygon, Polygon } from 'geojson';
+export declare const BUFFER_PX_AT_Z13 = 200;
+export declare const BUFFER_PX_AT_Z17 = 350;
+export declare const MIN_MISSING_AREA_RATIO = 0.005;
+export declare const FULL_FETCH_RATIO = 0.85;
+export declare const MAX_STRIP_REQUESTS = 2;
+export declare const MAX_HISTORY_FEATURES = 40;
+export declare const MAX_HISTORY_GROUPS = 20;
+export type MapSizePx = {
+    width: number;
+    height: number;
+};
+export type CoverageFetchKind = 'initial' | 'strip' | 'full';
+export type CoverageFetchRequest = {
+    bounds: MapBounds;
+    kind: CoverageFetchKind;
+};
+export type CoverageFetchProps = {
+    groupId: string;
+    fetchedAt: string;
+    requestIndex: number;
+    requestCount: number;
+    kind: CoverageFetchKind;
+};
+export declare function emptyFetchHistory(): FeatureCollection<Polygon, CoverageFetchProps>;
+export declare function bufferPxAtZoom(zoom: number): number;
+export declare function boundsToPolygon(bounds: MapBounds): Feature<Polygon>;
+export declare function polygonToBounds(feature: Feature<Polygon | MultiPolygon>): MapBounds;
+export declare function isValidBounds(bounds: MapBounds): boolean;
+export declare function boundsArea(bounds: MapBounds): number;
+export declare function bufferBoundsInViewport(request: MapBounds, viewport: MapBounds, zoom: number, mapSizePx: MapSizePx): MapBounds;
+export declare function clampBoundsToViewport(request: MapBounds, viewport: MapBounds): MapBounds;
+export declare function createViewportFetchRequest(viewport: MapBounds, zoom: number, mapSizePx: MapSizePx, kind: CoverageFetchKind): CoverageFetchRequest | null;
+export declare function computeMissingFetchRequests(viewport: MapBounds, coverage: Feature<Polygon | MultiPolygon> | null, zoom: number, mapSizePx: MapSizePx): CoverageFetchRequest[];
+export declare function unionIntoCoverage(coverage: Feature<Polygon | MultiPolygon> | null, requestBounds: MapBounds): Feature<Polygon | MultiPolygon>;
+export declare function capFetchHistory(history: FeatureCollection<Polygon, CoverageFetchProps>): FeatureCollection<Polygon, CoverageFetchProps>;
+export declare function appendFetchHistory(history: FeatureCollection<Polygon, CoverageFetchProps>, groupId: string, fetchedAt: string, requests: CoverageFetchRequest[]): FeatureCollection<Polygon, CoverageFetchProps>;

package/dist/create-osm-coverage-api.d.ts

@@ -0,0 +1,36 @@
+import { type MapBounds, type ParsedOsmData } from '@osm-editor-kit/osm-data';
+import { type QueryClient } from '@tanstack/react-query';
+import type { Feature, FeatureCollection, MultiPolygon, Polygon } from 'geojson';
+import { type CoverageFetchProps, type MapSizePx } from './coverage-geometry';
+export type { CoverageFetchProps, MapSizePx } from './coverage-geometry';
+export type OsmCoverageQueryData = {
+    graph: ParsedOsmData;
+    coverage: Feature<Polygon | MultiPolygon> | null;
+    fetchHistory: FeatureCollection<Polygon, CoverageFetchProps>;
+};
+export type CreateOsmCoverageApiOptions<TSessionParams> = {
+    getSessionKey: (params: TSessionParams) => readonly unknown[];
+    minZoom: number;
+    getDownloadUrl: (bounds: MapBounds, params: TSessionParams) => string;
+    download?: (url: string) => Promise<ParsedOsmData>;
+    /** When false, session queries stay enabled=false and ensureCoverage skips network. */
+    isNetworkEnabled?: () => boolean;
+};
+export declare function createOsmCoverageApi<TSessionParams>({ getSessionKey, minZoom, getDownloadUrl, download, isNetworkEnabled, }: CreateOsmCoverageApiOptions<TSessionParams>): {
+    emptyData: () => OsmCoverageQueryData;
+    sessionKey: (params: TSessionParams) => readonly unknown[];
+    coverageKey: (params: TSessionParams) => readonly [...unknown[], "coverage"];
+    ensureCoverage: (queryClient: QueryClient, { bounds, zoom, mapSizePx, force, ...sessionParams }: {
+        bounds: MapBounds;
+        zoom: number;
+        mapSizePx: MapSizePx;
+        force?: boolean;
+    } & TSessionParams) => Promise<{
+        skipped: boolean;
+    }>;
+    createUseQuery: (useSessionParams: () => TSessionParams) => <TData = OsmCoverageQueryData>(options?: {
+        select?: (data: OsmCoverageQueryData) => TData;
+    }) => import("@tanstack/react-query").DefinedUseQueryResult<NoInfer<TData>, Error>;
+    createUseIsFetching: (useSessionParams: () => TSessionParams) => () => boolean;
+    createUseResetOnSessionChange: (useSessionParams: () => TSessionParams) => () => void;
+};

package/dist/dev-osm-map-fixture/dev-osm-map-fixture-url.d.ts

@@ -0,0 +1,4 @@
+import type { MapBounds } from '@osm-editor-kit/osm-data';
+export declare const DEV_OSM_MAP_FIXTURE_ROUTE = "dev-osm-map-fixture";
+/** Browser-safe URL for a local dev Map API bbox slice (no Node/fs imports). */
+export declare function devOsmMapFixtureMapUrl(baseUrl: string, bounds: MapBounds): string;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { DEV_OSM_MAP_FIXTURE_ROUTE, devOsmMapFixtureMapUrl, } from './dev-osm-map-fixture/dev-osm-map-fixture-url';
+export { createOsmCoverageApi, type OsmCoverageQueryData } from './create-osm-coverage-api';
+export { type CoverageFetchProps, type CoverageFetchKind, type MapSizePx, boundsToPolygon, bufferPxAtZoom, computeMissingFetchRequests, unionIntoCoverage, } from './coverage-geometry';
+export { OsmDataSource } from './osm-data-source';
+export { boundsToOverpassBbox, buildOverpassInterpreterUrl } from './overpass-url';
+export { overpassDeUrl, overpassVkUrl } from './overpass-urls';

package/dist/index.js

@@ -0,0 +1,361 @@
+import { downloadOsmData, emptyParsedOsmData, mergeParsedOsm } from '@osm-editor-kit/osm-data';
+import { useQuery, useIsFetching, useQueryClient } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import area from '@turf/area';
+import bbox from '@turf/bbox';
+import bboxPolygon from '@turf/bbox-polygon';
+import difference from '@turf/difference';
+import flatten from '@turf/flatten';
+import { featureCollection } from '@turf/helpers';
+import intersect from '@turf/intersect';
+import union from '@turf/union';
+
+// src/dev-osm-map-fixture/dev-osm-map-fixture-url.ts
+var DEV_OSM_MAP_FIXTURE_ROUTE = "dev-osm-map-fixture";
+function devOsmMapFixtureMapUrl(baseUrl, bounds) {
+  const base = baseUrl.replace(/\/$/, "");
+  const bbox2 = [bounds.west, bounds.south, bounds.east, bounds.north].join(",");
+  return `${base}/${DEV_OSM_MAP_FIXTURE_ROUTE}/api/0.6/map?bbox=${bbox2}`;
+}
+var BUFFER_PX_AT_Z13 = 200;
+var MIN_MISSING_AREA_RATIO = 5e-3;
+var FULL_FETCH_RATIO = 0.85;
+var MAX_STRIP_REQUESTS = 2;
+var MAX_HISTORY_FEATURES = 40;
+var MAX_HISTORY_GROUPS = 20;
+var HIGH_FILL_RATIO = 0.7;
+function emptyFetchHistory() {
+  return { type: "FeatureCollection", features: [] };
+}
+function bufferPxAtZoom(zoom) {
+  return BUFFER_PX_AT_Z13 + 37.5 * (zoom - 13);
+}
+function boundsToPolygon(bounds) {
+  return bboxPolygon([bounds.west, bounds.south, bounds.east, bounds.north]);
+}
+function polygonToBounds(feature) {
+  const [west, south, east, north] = bbox(feature);
+  return { west, south, east, north };
+}
+function isValidBounds(bounds) {
+  return bounds.west < bounds.east && bounds.south < bounds.north;
+}
+function boundsArea(bounds) {
+  return area(boundsToPolygon(bounds));
+}
+function bufferBoundsInViewport(request, viewport, zoom, mapSizePx) {
+  const px = bufferPxAtZoom(zoom);
+  const lonBuffer = px * (viewport.east - viewport.west) / mapSizePx.width;
+  const latBuffer = px * (viewport.north - viewport.south) / mapSizePx.height;
+  return {
+    west: request.west - lonBuffer,
+    south: request.south - latBuffer,
+    east: request.east + lonBuffer,
+    north: request.north + latBuffer
+  };
+}
+function clampBoundsToViewport(request, viewport) {
+  return {
+    west: Math.max(request.west, viewport.west),
+    south: Math.max(request.south, viewport.south),
+    east: Math.min(request.east, viewport.east),
+    north: Math.min(request.north, viewport.north)
+  };
+}
+function prepareFetchBounds(request, viewport, zoom, mapSizePx) {
+  const buffered = clampBoundsToViewport(
+    bufferBoundsInViewport(request, viewport, zoom, mapSizePx),
+    viewport
+  );
+  if (!isValidBounds(buffered)) return null;
+  const viewportArea = boundsArea(viewport);
+  if (boundsArea(buffered) < MIN_MISSING_AREA_RATIO * viewportArea) return null;
+  return buffered;
+}
+function missingParts(viewport, coverage) {
+  const viewportPoly = boundsToPolygon(viewport);
+  const missing = difference(featureCollection([viewportPoly, coverage]));
+  if (!missing) return [];
+  return flatten(missing).features.filter(
+    (feature) => feature.geometry.type === "Polygon"
+  );
+}
+function stripCandidates(viewport, coverage, missingPart) {
+  const viewportPoly = boundsToPolygon(viewport);
+  const covered = intersect(featureCollection([viewportPoly, coverage]));
+  if (!covered) return [];
+  const coveredBbox = polygonToBounds(covered);
+  const candidates = [
+    {
+      west: viewport.west,
+      south: viewport.south,
+      east: coveredBbox.west,
+      north: viewport.north
+    },
+    {
+      west: coveredBbox.east,
+      south: viewport.south,
+      east: viewport.east,
+      north: viewport.north
+    },
+    {
+      west: viewport.west,
+      south: coveredBbox.north,
+      east: viewport.east,
+      north: viewport.north
+    },
+    {
+      west: viewport.west,
+      south: viewport.south,
+      east: viewport.east,
+      north: coveredBbox.south
+    }
+  ];
+  return candidates.filter((strip) => {
+    if (!isValidBounds(strip)) return false;
+    const overlap = intersect(featureCollection([boundsToPolygon(strip), missingPart]));
+    return overlap !== null && area(overlap) > 0;
+  });
+}
+function chooseBoundsForMissingPart(viewport, coverage, missingPart) {
+  const partArea = area(missingPart);
+  const partBbox = polygonToBounds(missingPart);
+  const fillRatio = partArea / area(boundsToPolygon(partBbox));
+  if (fillRatio >= HIGH_FILL_RATIO) {
+    return [partBbox];
+  }
+  const strips = stripCandidates(viewport, coverage, missingPart);
+  const stripAreas = strips.map((strip) => ({ bounds: strip, area: boundsArea(strip) })).sort((a, b) => b.area - a.area);
+  const stripTotalArea = stripAreas.reduce((sum, strip) => sum + strip.area, 0);
+  const bboxArea = boundsArea(partBbox);
+  if (strips.length > 0 && stripTotalArea < bboxArea) {
+    return stripAreas.slice(0, MAX_STRIP_REQUESTS).map((strip) => strip.bounds);
+  }
+  return [partBbox];
+}
+function createViewportFetchRequest(viewport, zoom, mapSizePx, kind) {
+  const prepared = prepareFetchBounds(viewport, viewport, zoom, mapSizePx);
+  return prepared ? { bounds: prepared, kind } : null;
+}
+function computeMissingFetchRequests(viewport, coverage, zoom, mapSizePx) {
+  const viewportArea = boundsArea(viewport);
+  if (!coverage) {
+    const initial = createViewportFetchRequest(viewport, zoom, mapSizePx, "initial");
+    return initial ? [initial] : [];
+  }
+  const parts = missingParts(viewport, coverage);
+  const significantParts = parts.filter(
+    (part) => area(part) >= MIN_MISSING_AREA_RATIO * viewportArea
+  );
+  if (significantParts.length === 0) return [];
+  const rawBounds = significantParts.flatMap(
+    (part) => chooseBoundsForMissingPart(viewport, coverage, part)
+  );
+  let requests = rawBounds.map((request) => {
+    const prepared = prepareFetchBounds(request, viewport, zoom, mapSizePx);
+    if (!prepared) return null;
+    return { bounds: prepared, area: boundsArea(prepared), kind: "strip" };
+  }).filter(
+    (request) => request !== null
+  );
+  if (requests.length === 0) return [];
+  requests.sort((a, b) => b.area - a.area);
+  const sumArea = requests.reduce((sum, request) => sum + request.area, 0);
+  if (sumArea >= FULL_FETCH_RATIO * viewportArea) {
+    const full = createViewportFetchRequest(viewport, zoom, mapSizePx, "full");
+    return full ? [full] : [];
+  }
+  requests = requests.slice(0, MAX_STRIP_REQUESTS);
+  return requests.map((request) => ({
+    bounds: request.bounds,
+    kind: request.kind
+  }));
+}
+function unionIntoCoverage(coverage, requestBounds) {
+  const requestPoly = boundsToPolygon(requestBounds);
+  if (!coverage) return requestPoly;
+  const merged = union(featureCollection([coverage, requestPoly]));
+  return merged ?? requestPoly;
+}
+function countDistinctGroups(features) {
+  return new Set(features.map((feature) => feature.properties.groupId)).size;
+}
+function capFetchHistory(history) {
+  let features = [...history.features];
+  while (features.length > MAX_HISTORY_FEATURES) {
+    features.shift();
+  }
+  while (countDistinctGroups(features) > MAX_HISTORY_GROUPS) {
+    const oldestGroupId = features[0]?.properties.groupId;
+    if (!oldestGroupId) break;
+    features = features.filter((feature) => feature.properties.groupId !== oldestGroupId);
+  }
+  return { type: "FeatureCollection", features };
+}
+function appendFetchHistory(history, groupId, fetchedAt, requests) {
+  const newFeatures = requests.map((request, requestIndex) => ({
+    type: "Feature",
+    geometry: boundsToPolygon(request.bounds).geometry,
+    properties: {
+      groupId,
+      fetchedAt,
+      requestIndex,
+      requestCount: requests.length,
+      kind: request.kind
+    }
+  }));
+  return capFetchHistory({
+    features: [...history.features, ...newFeatures]
+  });
+}
+
+// src/create-osm-coverage-api.ts
+function createOsmCoverageApi({
+  getSessionKey,
+  minZoom,
+  getDownloadUrl,
+  download = downloadOsmData,
+  isNetworkEnabled
+}) {
+  const getCoverageKey = (params) => [...getSessionKey(params), "coverage"];
+  const networkEnabled = () => isNetworkEnabled?.() ?? true;
+  const coverageChains = /* @__PURE__ */ new Map();
+  function emptyData() {
+    return {
+      graph: emptyParsedOsmData(),
+      coverage: null,
+      fetchHistory: emptyFetchHistory()
+    };
+  }
+  async function ensureCoverage(queryClient, {
+    bounds,
+    zoom,
+    mapSizePx,
+    force = false,
+    ...sessionParams
+  }) {
+    if (!networkEnabled()) {
+      return { skipped: true };
+    }
+    const params = sessionParams;
+    const sessionKey = getSessionKey(params);
+    const coverageKey = getCoverageKey(params);
+    const chainKey = JSON.stringify(sessionKey);
+    const run = async () => {
+      const requestKey = [...coverageKey, crypto.randomUUID()];
+      return queryClient.fetchQuery({
+        queryKey: requestKey,
+        queryFn: async () => {
+          const current = force ? emptyData() : queryClient.getQueryData(sessionKey) ?? emptyData();
+          if (zoom < minZoom) {
+            return { skipped: true };
+          }
+          const requests = force ? (() => {
+            const full = createViewportFetchRequest(bounds, zoom, mapSizePx, "full");
+            return full ? [full] : [];
+          })() : computeMissingFetchRequests(bounds, current.coverage, zoom, mapSizePx);
+          if (requests.length === 0) {
+            return { skipped: true };
+          }
+          const groupId = crypto.randomUUID();
+          const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+          let coverage = force ? null : current.coverage;
+          let fetchHistory = force ? emptyFetchHistory() : current.fetchHistory;
+          const fetchedGraphs = [];
+          for (const request of requests) {
+            const url = getDownloadUrl(request.bounds, params);
+            fetchedGraphs.push(await download(url));
+            coverage = unionIntoCoverage(coverage, request.bounds);
+          }
+          fetchHistory = appendFetchHistory(fetchHistory, groupId, fetchedAt, requests);
+          queryClient.setQueryData(sessionKey, (latest) => {
+            const base = force ? emptyData() : latest ?? emptyData();
+            let graph = base.graph;
+            for (const newGraph of fetchedGraphs) {
+              graph = mergeParsedOsm(graph, newGraph);
+            }
+            return { graph, coverage, fetchHistory };
+          });
+          return { skipped: false };
+        },
+        staleTime: 0,
+        gcTime: 0
+      });
+    };
+    const previous = coverageChains.get(chainKey) ?? Promise.resolve();
+    const next = previous.then(run, run);
+    coverageChains.set(
+      chainKey,
+      next.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+    return next;
+  }
+  function createUseQuery(useSessionParams) {
+    return function useOsmQuery(options) {
+      const params = useSessionParams();
+      return useQuery({
+        queryKey: getSessionKey(params),
+        queryFn: () => emptyData(),
+        initialData: emptyData(),
+        staleTime: Number.POSITIVE_INFINITY,
+        enabled: networkEnabled(),
+        select: options?.select
+      });
+    };
+  }
+  function createUseIsFetching(useSessionParams) {
+    return function useIsOsmFetching() {
+      const params = useSessionParams();
+      return useIsFetching({ queryKey: getCoverageKey(params) }) > 0;
+    };
+  }
+  function createUseResetOnSessionChange(useSessionParams) {
+    return function useResetOsmOnSessionChange() {
+      const queryClient = useQueryClient();
+      const params = useSessionParams();
+      useEffect(
+        function resetOsmDataOnSessionChange() {
+          queryClient.setQueryData(getSessionKey(params), emptyData());
+          queryClient.removeQueries({
+            queryKey: getCoverageKey(params)
+          });
+        },
+        [params, queryClient]
+      );
+    };
+  }
+  return {
+    emptyData,
+    sessionKey: getSessionKey,
+    coverageKey: getCoverageKey,
+    ensureCoverage,
+    createUseQuery,
+    createUseIsFetching,
+    createUseResetOnSessionChange
+  };
+}
+
+// src/osm-data-source.ts
+var OsmDataSource = /* @__PURE__ */ ((OsmDataSource2) => {
+  OsmDataSource2[OsmDataSource2["OverpassDe"] = 0] = "OverpassDe";
+  OsmDataSource2[OsmDataSource2["OsmOrg"] = 1] = "OsmOrg";
+  OsmDataSource2[OsmDataSource2["OverpassVk"] = 2] = "OverpassVk";
+  return OsmDataSource2;
+})(OsmDataSource || {});
+
+// src/overpass-url.ts
+function boundsToOverpassBbox(bounds) {
+  return [bounds.south, bounds.west, bounds.north, bounds.east].join(",");
+}
+function buildOverpassInterpreterUrl(server, query) {
+  return server + encodeURIComponent(query);
+}
+
+// src/overpass-urls.ts
+var overpassDeUrl = "https://overpass-api.de/api/interpreter?data=";
+var overpassVkUrl = "https://maps.mail.ru/osm/tools/overpass/api/interpreter?data=";
+
+export { DEV_OSM_MAP_FIXTURE_ROUTE, OsmDataSource, boundsToOverpassBbox, boundsToPolygon, bufferPxAtZoom, buildOverpassInterpreterUrl, computeMissingFetchRequests, createOsmCoverageApi, devOsmMapFixtureMapUrl, overpassDeUrl, overpassVkUrl, unionIntoCoverage };

package/dist/osm-data-source.d.ts

@@ -0,0 +1,5 @@
+export declare enum OsmDataSource {
+    OverpassDe = 0,
+    OsmOrg = 1,
+    OverpassVk = 2
+}

package/dist/overpass-url.d.ts

@@ -0,0 +1,3 @@
+import type { MapBounds } from '@osm-editor-kit/osm-data';
+export declare function boundsToOverpassBbox(bounds: MapBounds): string;
+export declare function buildOverpassInterpreterUrl(server: string, query: string): string;

package/dist/overpass-urls.d.ts

@@ -0,0 +1,2 @@
+export declare const overpassDeUrl = "https://overpass-api.de/api/interpreter?data=";
+export declare const overpassVkUrl = "https://maps.mail.ru/osm/tools/overpass/api/interpreter?data=";

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@osm-editor-kit/osm-coverage",
+  "version": "0.1.0-alpha.0",
+  "description": "Incremental OSM coverage fetching for map viewports with TanStack Query session state.",
+  "license": "MIT",
+  "author": "Tobias Jordans",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/osmberlin/street-space-editor.git",
+    "directory": "packages/osm-coverage"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "scripts": {
+    "build": "tsup && rm -f .tsbuildinfo && tsc -p tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "test-run": "bun test src/test",
+    "prepublishOnly": "bun run build && bun ../../scripts/package-exports-for-publish.ts",
+    "postpublish": "bun ../../scripts/package-exports-restore.ts",
+    "prepack": "bun ../../scripts/package-exports-for-publish.ts",
+    "postpack": "bun ../../scripts/package-exports-restore.ts"
+  },
+  "dependencies": {
+    "@osm-editor-kit/osm-data": "workspace:*",
+    "@tanstack/react-query": "^5.85.5",
+    "@turf/area": "^7.3.5",
+    "@turf/bbox": "^7.3.5",
+    "@turf/bbox-polygon": "^7.3.5",
+    "@turf/difference": "^7.3.5",
+    "@turf/flatten": "^7.3.5",
+    "@turf/helpers": "^7.3.5",
+    "@turf/intersect": "^7.3.5",
+    "@turf/union": "^7.3.5"
+  },
+  "devDependencies": {
+    "@types/geojson": "^7946.0.16",
+    "@types/react": "^19.1.10",
+    "bun-types": "^1.2.20",
+    "react": "^19.1.1",
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "publishExports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}