osmfeatures 0.1.2 → 0.2.1

package/README.md

@@ -73,7 +73,8 @@ The geographical area for the request in terms of GPS coordinates or specific OS
 | Param    | Type     | Description                                        |
 | -------- | -------- | -------------------------------------------------- |
 | `bbox`   | `string` | Bounding box as `min_lon,min_lat,max_lon,max_lat`. |
-| `around` | `string` | Circle filter as `lon,lat,radius_m`.               |
+| `location` | `string` | Point for a radius search as `lat,lng`. Requires `radius`. |
+| `radius` | `number` | Search radius in metres. Requires `location`. |
 | `osmIds` | `string` | Comma-separated OSM IDs to fetch by id.            |
 
 
@@ -167,7 +168,7 @@ console.log(all.meta.page_count, all.meta.has_more, all.meta.units_charged);
 
 ### Params
 
-Same filter params as `query` (`bbox`, `tags`, `orTags`, `notTags`, `type`, `shape`, `zoom`, `around`, `osmIds`, `minLengthM`, `maxLengthM`, `minAreaM2`, `maxAreaM2`, `centroid`, `clipGeometry`, `disableBudgetWarning`), plus:
+Same filter params as `query` (`bbox`, `tags`, `orTags`, `notTags`, `type`, `shape`, `zoom`, `location`, `radius`, `osmIds`, `minLengthM`, `maxLengthM`, `minAreaM2`, `maxAreaM2`, `centroid`, `clipGeometry`, `disableBudgetWarning`), plus:
 
 
 | Param          | Type            | Default                | Description                                                                                                                                               |
@@ -199,4 +200,79 @@ Same fields as `query`, plus:
 Also exports layer presets (`resolveLayerFromQuery`, `OSM_FEATURES_LAYER_PRESETS`, ...)
 and GeoJSON payload helpers (`featureCentroid`, `geometryBounds`, `parseFeatureId`, ...).
 
+## `estimate_cost`
+
+Preflight credit cost via `GET /v2/osm_features/cost`. Same filter params as `query`. No OSM data is fetched.
+
+```ts
+const estimate = await client.estimate_cost({
+  bbox: '18.06,59.32,18.09,59.34',
+  tags: ['building'],
+});
+console.log(estimate.estimated_credits);
+```
+
+## `usage`
+
+This month's unit-budget usage via `GET /v1/usage`.
+
+```ts
+const usage = await client.usage();
+console.log(usage.tier, usage.usage_this_month, usage.remaining_this_month);
+```
+
+## `places_search` / `places_nearby` / `places_details`
+
+Place discovery and lookup. Search is a bbox or `location`+`radius`. Nearby ranks one set from a point. Details refetches a search/nearby feature id (`node/123`). Search and nearby hours use each place's local timezone; optional `asOf` pins the evaluation instant.
+
+```ts
+const origin = { lat: 59.316, lon: 18.075 };
+
+const cafes = await client.places_search({
+  location: origin,
+  radius: 800,
+  orTags: ['amenity=cafe'],
+  openNow: true,
+  asOf: '2026-08-10T18:00:00+02:00',
+});
+
+const nearby = await client.places_nearby({
+  location: origin,
+  orTags: ['amenity=cafe'],
+  limit: 5,
+  openNow: true,
+  asOf: '2026-08-10T18:00:00+02:00',
+});
+
+const first = (cafes.features as { id: string }[])[0];
+const details = await client.places_details({ osmType: first.id });
+```
+
+`places_details` also accepts `{ osmType: 'node', osmId: 123 }`. Hours are annotated at request time in the place's local timezone.
+
+## `routes_isochrone` / `routes_path` / `routes_optimized_path`
+
+Walk or bicycle routing via `POST /v1/routes/*`. Points accept `lon` or `lng`.
+
+```ts
+const origin = { lon: 18.075, lat: 59.316 };
+const cafe = { lon: 18.08, lat: 59.318 };
+
+const iso = await client.routes_isochrone({
+  origin,
+  durationS: 600,
+});
+
+const path = await client.routes_path({
+  stops: [origin, cafe],
+});
+
+const tour = await client.routes_optimized_path({
+  start: origin,
+  stops: [cafe],
+});
+```
+
+`routes_isochrone` takes exactly one of `maxDistanceM` or `durationS`. `routes_path` follows `stops` in listed order (no TSP). `routes_optimized_path` orders `stops` from `start`; `loop` (default true) returns to start. Optional `searchBufferM` and `travelMode` (`WALK` or `BICYCLE`).
+
 Read the full API reference here [https://maplark.com/developer](https://maplark.com/developer) such as the OpenAPI 2.0 HTTP docs.

package/dist/index.d.ts

@@ -27,7 +27,7 @@ export type OSMFeaturesResult = {
 };
 /** Layer filters from presets / custom resolve. Pass into `resolveRequest` or spread into `query`. */
 export type OSMFeaturesLayer = {
-    bbox: string;
+    bbox?: string;
     tags?: string[];
     orTags?: string[];
     notTags?: string[];
@@ -39,7 +39,10 @@ export type OSMFeaturesParams = OSMFeaturesLayer & {
     limit?: number;
     cursor?: string;
     zoom?: number;
-    around?: string;
+    /** Point for a radius search as `lat,lng`. Requires `radius`. */
+    location?: string;
+    /** Search radius in metres. Requires `location`. */
+    radius?: number;
     osmIds?: string;
     minLengthM?: number;
     maxLengthM?: number;
@@ -54,6 +57,60 @@ export type OSMFeaturesParams = OSMFeaturesLayer & {
 };
 type QueryValue = unknown;
 export type OSMFeaturesQuery = Record<string, QueryValue>;
+/** Routing point. Accepts ``lon`` or ``lng``. */
+export type LonLat = {
+    lat: number;
+} & ({
+    lon: number;
+} | {
+    lng: number;
+});
+export type RouteTravelMode = 'WALK' | 'BICYCLE';
+export type RoutesIsochroneParams = {
+    origin: LonLat;
+    maxDistanceM?: number;
+    durationS?: number;
+    searchBufferM?: number;
+    travelMode?: RouteTravelMode;
+};
+export type RoutesPathParams = {
+    stops: LonLat[];
+    searchBufferM?: number;
+    travelMode?: RouteTravelMode;
+};
+export type RoutesOptimizedPathParams = {
+    start: LonLat;
+    stops: LonLat[];
+    searchBufferM?: number;
+    loop?: boolean;
+    travelMode?: RouteTravelMode;
+};
+export type PlacesSearchParams = {
+    bbox?: string;
+    location?: LonLat;
+    radius?: number;
+    type?: string;
+    tags?: string[];
+    orTags?: string[];
+    limit?: number;
+    openNow?: boolean;
+    asOf?: string;
+};
+export type PlacesNearbyParams = {
+    location: LonLat;
+    radius?: number;
+    type?: string;
+    tags?: string[];
+    orTags?: string[];
+    limit?: number;
+    openNow?: boolean;
+    asOf?: string;
+};
+export type PlacesDetailsParams = {
+    /** ``node`` / ``way`` / ``relation``, or a full ``node/123`` feature id. */
+    osmType: string;
+    osmId?: number | string;
+};
 type OSMFeaturesDependencies = {
     fetchFn?: typeof fetch;
     sleepFn?: (ms: number) => Promise<void>;
@@ -80,12 +137,18 @@ export declare class OSMFeatures {
     /** Map Express/query params + resolved layer into flat `query` / `query_all` params. */
     resolveRequest(query: OSMFeaturesQuery, layer: OSMFeaturesLayer): OSMFeaturesParams;
     private throwUpstreamError;
+    /** GET/POST with 429 retry. Throws on non-OK. */
+    private _fetchOk;
+    /** POST JSON to a geo-agent path. */
+    private _postJson;
+    /** GET JSON from a geo-agent or account path. */
+    private _getJson;
     /** Single HTTP request with retry. Throws on non-OK (same role as Python `_raw_query`). */
     private _rawQuery;
     /** Single upstream page. Params map 1:1 to server query string (no tiling). */
-    query({ bbox, tags, orTags, notTags, type, shape, limit, cursor, zoom, around, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, }: OSMFeaturesParams, dependencies?: OSMFeaturesDependencies): Promise<OSMFeaturesResult>;
+    query({ bbox, tags, orTags, notTags, type, shape, limit, cursor, zoom, location, radius, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, }: OSMFeaturesParams, dependencies?: OSMFeaturesDependencies): Promise<OSMFeaturesResult>;
     /** Auto-paginate (and optionally tile) until complete. Each page uses `_rawQuery`. */
-    query_all({ bbox, tags, orTags, notTags, type, shape, zoom, around, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, limitPerPage, bboxTiles, maxPages, maxFeatures, }: Omit<OSMFeaturesParams, 'limit' | 'cursor'> & {
+    query_all({ bbox, tags, orTags, notTags, type, shape, zoom, location, radius, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, limitPerPage, bboxTiles, maxPages, maxFeatures, }: Omit<OSMFeaturesParams, 'limit' | 'cursor'> & {
         /** Upstream `limit` per HTTP request (page size). */
         limitPerPage?: number;
         bboxTiles?: number;
@@ -93,6 +156,22 @@ export declare class OSMFeatures {
         /** Cap on merged features. `null` = no cap. */
         maxFeatures?: number | null;
     }, dependencies?: OSMFeaturesDependencies): Promise<OSMGeoJSONResult>;
+    /** Preflight credit cost (``GET /v2/osm_features/cost``). */
+    estimate_cost(params?: OSMFeaturesParams, dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
+    /** This month's unit-budget usage (``GET /v1/usage``). */
+    usage(dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
+    /** Find places in a bbox or radius (``POST /v1/places/search``). */
+    places_search(params: PlacesSearchParams, dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
+    /** Nearest places from a point (``POST /v1/places/nearby``). */
+    places_nearby(params: PlacesNearbyParams, dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
+    /** One place by OSM id (``GET /v1/places/{osm_type}/{osm_id}``). */
+    places_details(params: PlacesDetailsParams, dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
+    /** Reach polygon along the walk/bike network (``POST /v1/routes/isochrone``). */
+    routes_isochrone(params: RoutesIsochroneParams, dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
+    /** Given-order walk/bike path (``POST /v1/routes/path``). */
+    routes_path(params: RoutesPathParams, dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
+    /** TSP walk/bike tour from ``start`` (``POST /v1/routes/optimized_path``). ``loop`` returns to start. */
+    routes_optimized_path(params: RoutesOptimizedPathParams, dependencies?: OSMFeaturesDependencies): Promise<Record<string, unknown>>;
 }
 export * from './geojson-feature.js';
 export * from './preset/index.js';

package/dist/index.js

@@ -21,6 +21,7 @@ function metaFromHeaders(headers, featureCount) {
     }
     return meta;
 }
+const PLACE_TYPES = new Set(['node', 'way', 'relation']);
 const DEFAULT_BASE_URL = 'https://api.maplark.com';
 const DEFAULT_LIMIT = 1000;
 const MAX_LIMIT = 6000;
@@ -145,7 +146,9 @@ export function splitBbox(bbox, tileCount) {
 }
 function buildFeaturesQuery(params) {
     const query = new URLSearchParams();
-    query.set('bbox', params.bbox);
+    if (params.bbox) {
+        query.set('bbox', params.bbox);
+    }
     query.set('limit', String(params.limit));
     if (params.cursor) {
         query.set('cursor', params.cursor);
@@ -153,8 +156,11 @@ function buildFeaturesQuery(params) {
     if (params.zoom != null) {
         query.set('zoom', String(params.zoom));
     }
-    if (params.around) {
-        query.set('around', params.around);
+    if (params.location) {
+        query.set('location', params.location);
+    }
+    if (params.radius != null) {
+        query.set('radius', String(params.radius));
     }
     if (params.osmIds) {
         query.set('osm_ids', params.osmIds);
@@ -197,6 +203,122 @@ function buildFeaturesQuery(params) {
     }
     return query;
 }
+function lonlat(point) {
+    const lon = 'lon' in point ? point.lon : point.lng;
+    return { lon, lat: point.lat };
+}
+function latlng(point) {
+    const lng = 'lng' in point ? point.lng : point.lon;
+    return { lat: point.lat, lng };
+}
+function parsePlaceRef(osmType, osmId) {
+    if (osmId == null) {
+        const raw = osmType.trim();
+        const slash = raw.indexOf('/');
+        if (slash < 0) {
+            throw appError(400, 'invalid_place_id', 'place id must be node|way|relation plus a positive osm_id');
+        }
+        return parsePlaceRef(raw.slice(0, slash), raw.slice(slash + 1));
+    }
+    const kind = osmType.trim().toLowerCase();
+    if (!PLACE_TYPES.has(kind)) {
+        throw appError(400, 'invalid_place_id', 'osm_type must be node, way, or relation');
+    }
+    const n = typeof osmId === 'number' ? osmId : Number.parseInt(String(osmId).trim(), 10);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw appError(400, 'invalid_place_id', 'osm_id must be a positive integer');
+    }
+    return { osmType: kind, osmId: n };
+}
+function placesSearchBody(params) {
+    const body = { limit: params.limit ?? 100 };
+    if (params.bbox != null) {
+        body['bbox'] = params.bbox;
+    }
+    if (params.location != null) {
+        body['location'] = latlng(params.location);
+    }
+    if (params.radius != null) {
+        body['radius'] = params.radius;
+    }
+    if (params.type != null) {
+        body['type'] = params.type;
+    }
+    if (params.tags?.length) {
+        body['tags'] = params.tags;
+    }
+    if (params.orTags?.length) {
+        body['orTags'] = params.orTags;
+    }
+    if (params.openNow) {
+        body['openNow'] = true;
+    }
+    if (params.asOf != null) {
+        body['asOf'] = params.asOf;
+    }
+    return body;
+}
+function placesNearbyBody(params) {
+    const body = {
+        location: latlng(params.location),
+        radius: params.radius ?? 1000,
+        limit: params.limit ?? 10,
+    };
+    if (params.type != null) {
+        body['type'] = params.type;
+    }
+    if (params.tags?.length) {
+        body['tags'] = params.tags;
+    }
+    if (params.orTags?.length) {
+        body['orTags'] = params.orTags;
+    }
+    if (params.openNow) {
+        body['openNow'] = true;
+    }
+    if (params.asOf != null) {
+        body['asOf'] = params.asOf;
+    }
+    return body;
+}
+function routesIsochroneBody(params) {
+    const body = {
+        origin: lonlat(params.origin),
+        travelMode: params.travelMode ?? 'WALK',
+    };
+    if (params.maxDistanceM != null) {
+        body['max_distance_m'] = params.maxDistanceM;
+    }
+    if (params.durationS != null) {
+        body['duration_s'] = params.durationS;
+    }
+    if (params.searchBufferM != null) {
+        body['search_buffer_m'] = params.searchBufferM;
+    }
+    return body;
+}
+function routesPathBody(params) {
+    const body = {
+        stops: params.stops.map(lonlat),
+        travelMode: params.travelMode ?? 'WALK',
+    };
+    if (params.searchBufferM != null) {
+        body['search_buffer_m'] = params.searchBufferM;
+    }
+    return body;
+}
+function routesOptimizedPathBody(params) {
+    const body = {
+        start: lonlat(params.start),
+        stops: params.stops.map(lonlat),
+        loop: params.loop ?? true,
+        travelMode: params.travelMode ?? 'WALK',
+    };
+    if (params.searchBufferM != null) {
+        body['search_buffer_m'] = params.searchBufferM;
+    }
+    return body;
+}
 function sleep(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
@@ -265,7 +387,8 @@ export class OSMFeatures {
             limit: parseLimit(query),
             cursor: optionalString(query, 'cursor'),
             zoom: optionalNumber(query, 'zoom'),
-            around: optionalString(query, 'around'),
+            location: optionalString(query, 'location'),
+            radius: optionalNumber(query, 'radius'),
             osmIds: optionalString(query, 'osm_ids'),
             minLengthM: optionalNumber(query, 'min_length_m'),
             maxLengthM: optionalNumber(query, 'max_length_m'),
@@ -287,25 +410,15 @@ export class OSMFeatures {
         err.upstreamDetail = upstreamDetail;
         throw err;
     }
-    /** Single HTTP request with retry. Throws on non-OK (same role as Python `_raw_query`). */
-    async _rawQuery(params, fetchFn, sleepFn, nowFn) {
-        const query = buildFeaturesQuery(params);
-        const upstreamUrl = new URL(`${this.apiBaseUrl}/v2/osm_features`);
-        for (const [key, value] of query.entries()) {
-            upstreamUrl.searchParams.append(key, value);
-        }
-        let upstream;
+    /** GET/POST with 429 retry. Throws on non-OK. */
+    async _fetchOk(url, init, fetchFn, sleepFn, nowFn) {
         let retryAttempt = 0;
         while (true) {
+            let upstream;
             try {
-                upstream = await fetchFn(upstreamUrl.toString(), {
-                    method: 'GET',
-                    headers: {
-                        Authorization: `Bearer ${this.apiKey}`,
-                        Accept: params.accept || GEOJSON_ACCEPT,
-                        'User-Agent': 'osmfeatures',
-                    },
-                    signal: AbortSignal.timeout(this.timeoutMs),
+                upstream = await fetchFn(url, {
+                    ...init,
+                    signal: init.signal ?? AbortSignal.timeout(this.timeoutMs),
                 });
             }
             catch (error) {
@@ -317,7 +430,7 @@ export class OSMFeatures {
                 throw err;
             }
             if (upstream.ok) {
-                break;
+                return upstream;
             }
             if (upstream.status === 429 && retryAttempt < this.retryAttempts) {
                 retryAttempt += 1;
@@ -346,6 +459,53 @@ export class OSMFeatures {
             }
             await this.throwUpstreamError(upstream);
         }
+    }
+    /** POST JSON to a geo-agent path. */
+    async _postJson(path, body, fetchFn, sleepFn, nowFn) {
+        const upstream = await this._fetchOk(`${this.apiBaseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                'User-Agent': 'osmfeatures',
+            },
+            body: JSON.stringify(body),
+        }, fetchFn, sleepFn, nowFn);
+        return (await upstream.json());
+    }
+    /** GET JSON from a geo-agent or account path. */
+    async _getJson(path, query, fetchFn, sleepFn, nowFn) {
+        const url = new URL(`${this.apiBaseUrl}${path}`);
+        const entries = query instanceof URLSearchParams ? query.entries() : Object.entries(query);
+        for (const [key, value] of entries) {
+            url.searchParams.append(key, value);
+        }
+        const upstream = await this._fetchOk(url.toString(), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                Accept: 'application/json',
+                'User-Agent': 'osmfeatures',
+            },
+        }, fetchFn, sleepFn, nowFn);
+        return (await upstream.json());
+    }
+    /** Single HTTP request with retry. Throws on non-OK (same role as Python `_raw_query`). */
+    async _rawQuery(params, fetchFn, sleepFn, nowFn) {
+        const query = buildFeaturesQuery(params);
+        const upstreamUrl = new URL(`${this.apiBaseUrl}/v2/osm_features`);
+        for (const [key, value] of query.entries()) {
+            upstreamUrl.searchParams.append(key, value);
+        }
+        const upstream = await this._fetchOk(upstreamUrl.toString(), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                Accept: params.accept || GEOJSON_ACCEPT,
+                'User-Agent': 'osmfeatures',
+            },
+        }, fetchFn, sleepFn, nowFn);
         if (isGeojsonAccept(params.accept)) {
             const body = (await upstream.json());
             const features = Array.isArray(body.features) ? body.features : [];
@@ -358,7 +518,7 @@ export class OSMFeatures {
         };
     }
     /** Single upstream page. Params map 1:1 to server query string (no tiling). */
-    async query({ bbox, tags, orTags, notTags, type, shape, limit = DEFAULT_LIMIT, cursor, zoom, around, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, }, dependencies = {}) {
+    async query({ bbox, tags, orTags, notTags, type, shape, limit = DEFAULT_LIMIT, cursor, zoom, location, radius, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, }, dependencies = {}) {
         const payload = await this._rawQuery({
             bbox,
             tags,
@@ -369,7 +529,8 @@ export class OSMFeatures {
             limit,
             cursor,
             zoom,
-            around,
+            location,
+            radius,
             osmIds,
             minLengthM,
             maxLengthM,
@@ -383,7 +544,7 @@ export class OSMFeatures {
         return payload;
     }
     /** Auto-paginate (and optionally tile) until complete. Each page uses `_rawQuery`. */
-    async query_all({ bbox, tags, orTags, notTags, type, shape, zoom, around, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, limitPerPage = DEFAULT_LIMIT, bboxTiles = 2, maxPages = 15, maxFeatures = 55_000, }, dependencies = {}) {
+    async query_all({ bbox, tags, orTags, notTags, type, shape, zoom, location, radius, osmIds, minLengthM, maxLengthM, minAreaM2, maxAreaM2, disableBudgetWarning, centroid, clipGeometry, accept, limitPerPage = DEFAULT_LIMIT, bboxTiles = 2, maxPages = 15, maxFeatures = 55_000, }, dependencies = {}) {
         if (!isGeojsonAccept(accept)) {
             throw appError(400, 'invalid_accept', 'query_all only supports GeoJSON; use query({ accept }) for binary encodings.');
         }
@@ -394,7 +555,7 @@ export class OSMFeatures {
         const sleepFn = dependencies.sleepFn ?? sleep;
         const nowFn = dependencies.nowFn ?? Date.now;
         const featureCap = maxFeatures == null ? Number.POSITIVE_INFINITY : maxFeatures;
-        const tileBboxes = splitBbox(bbox, bboxTiles);
+        const tileBboxes = bbox ? splitBbox(bbox, bboxTiles) : [undefined];
         const allFeatures = [];
         let pageCount = 0;
         let lastPage = null;
@@ -412,7 +573,8 @@ export class OSMFeatures {
             shape,
             limit: limitPerPage,
             zoom,
-            around,
+            location,
+            radius,
             osmIds,
             minLengthM,
             maxLengthM,
@@ -500,6 +662,58 @@ export class OSMFeatures {
         }
         return resultFromFeatures(features, meta);
     }
+    /** Preflight credit cost (``GET /v2/osm_features/cost``). */
+    async estimate_cost(params = {}, dependencies = {}) {
+        return this._getJson('/v2/osm_features/cost', buildFeaturesQuery({
+            bbox: params.bbox,
+            tags: params.tags,
+            orTags: params.orTags,
+            notTags: params.notTags,
+            type: params.type,
+            shape: params.shape,
+            limit: params.limit ?? DEFAULT_LIMIT,
+            zoom: params.zoom,
+            location: params.location,
+            radius: params.radius,
+            osmIds: params.osmIds,
+            minLengthM: params.minLengthM,
+            maxLengthM: params.maxLengthM,
+            minAreaM2: params.minAreaM2,
+            maxAreaM2: params.maxAreaM2,
+            disableBudgetWarning: params.disableBudgetWarning,
+            centroid: params.centroid,
+            clipGeometry: params.clipGeometry,
+        }), dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
+    /** This month's unit-budget usage (``GET /v1/usage``). */
+    async usage(dependencies = {}) {
+        return this._getJson('/v1/usage', {}, dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
+    /** Find places in a bbox or radius (``POST /v1/places/search``). */
+    async places_search(params, dependencies = {}) {
+        return this._postJson('/v1/places/search', placesSearchBody(params), dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
+    /** Nearest places from a point (``POST /v1/places/nearby``). */
+    async places_nearby(params, dependencies = {}) {
+        return this._postJson('/v1/places/nearby', placesNearbyBody(params), dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
+    /** One place by OSM id (``GET /v1/places/{osm_type}/{osm_id}``). */
+    async places_details(params, dependencies = {}) {
+        const { osmType, osmId } = parsePlaceRef(params.osmType, params.osmId);
+        return this._getJson(`/v1/places/${osmType}/${osmId}`, {}, dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
+    /** Reach polygon along the walk/bike network (``POST /v1/routes/isochrone``). */
+    async routes_isochrone(params, dependencies = {}) {
+        return this._postJson('/v1/routes/isochrone', routesIsochroneBody(params), dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
+    /** Given-order walk/bike path (``POST /v1/routes/path``). */
+    async routes_path(params, dependencies = {}) {
+        return this._postJson('/v1/routes/path', routesPathBody(params), dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
+    /** TSP walk/bike tour from ``start`` (``POST /v1/routes/optimized_path``). ``loop`` returns to start. */
+    async routes_optimized_path(params, dependencies = {}) {
+        return this._postJson('/v1/routes/optimized_path', routesOptimizedPathBody(params), dependencies.fetchFn ?? fetch, dependencies.sleepFn ?? sleep, dependencies.nowFn ?? Date.now);
+    }
 }
 export * from './geojson-feature.js';
 export * from './preset/index.js';

package/dist/preset/catalog.js

@@ -37,6 +37,7 @@ export const OSM_FEATURES_LAYER_PRESETS = {
             'amenity=pub',
             'amenity=biergarten',
         ],
+        shape: 'polygon',
     },
     shops_commerce: {
         id: 'shops_commerce',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osmfeatures",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Get OpenStreetMap features such as buildings, roads, or points of interest from dedicated servers with a single API call in GeoJSON, FlatGeobuf, Geoparquet, and CSV formats.",
   "type": "module",
   "main": "./dist/index.js",