@object-ui/plugin-map 17.3.0 → 17.6.0

package/README.md

@@ -1,15 +1,19 @@
 # @object-ui/plugin-map
 
-Map visualization plugin for Object UI - Display geographic data with interactive maps.
+Map view plugin for Object UI.
 
-## Features
+Renders the records of an **ObjectQL query** as markers on a MapLibre map: every
+marker comes from a record's own coordinate fields, and the first paint frames the
+records that were fetched. It is a *view over data* — there is no authored marker
+list, and no pin you place by hand.
 
-- **Interactive Maps** - Zoomable, pannable map visualization
-- **Markers** - Add markers with custom icons and popups
-- **Layers** - Multiple map layers support
-- **Geolocation** - User location detection
-- **Customizable** - Tailwind CSS styling support
-- **Responsive** - Mobile-friendly map controls
+Importing the package registers two component types on the `ComponentRegistry`,
+both resolving to the same renderer:
+
+- `object-map` — the object-bound renderer
+- `map` — the bare spec view-type name (`ViewTypeSchema`'s `'map'`), for a node
+  authored with it directly. Inside an `ObjectView`, a `map` view is compiled to
+  an `object-map` node, so both spellings end at the same component.
 
 ## Installation
 
@@ -17,274 +21,171 @@ Map visualization plugin for Object UI - Display geographic data with interactiv
 pnpm add @object-ui/plugin-map
 ```
 
-## Usage
-
-### Automatic Registration (Side-Effect Import)
-
-```typescript
-// In your app entry point (e.g., App.tsx or main.tsx)
-import '@object-ui/plugin-map';
-
-// Now you can use map types in your schemas
-const schema = {
-  type: 'map',
-  center: { lat: 37.7749, lng: -122.4194 },
-  zoom: 12,
-  markers: [
-    { lat: 37.7749, lng: -122.4194, label: 'San Francisco' }
-  ]
-};
-```
-
-### Manual Registration
-
-```typescript
-import { mapComponents } from '@object-ui/plugin-map';
-import { ComponentRegistry } from '@object-ui/core';
-
-// Register map components
-Object.entries(mapComponents).forEach(([type, component]) => {
-  ComponentRegistry.register(type, component);
-});
-```
-
-## Schema API
+## Requires a bundler — plain Node cannot import this package
 
-### Map
+`ObjectMap` imports MapLibre's stylesheet at module scope
+(`import 'maplibre-gl/dist/maplibre-gl.css'`), and Node has no loader for `.css` at all.
+Importing the published entry from plain Node ESM — no bundler, no loader hooks — therefore
+resolves and then fails during evaluation:
 
-Display an interactive map:
-
-```typescript
-{
-  type: 'map',
-  center: { lat: number, lng: number },
-  zoom?: number,                  // Default: 10
-  markers?: MapMarker[],
-  layers?: MapLayer[],
-  height?: number | string,
-  onMarkerClick?: (marker) => void,
-  className?: string
-}
-```
-
-### Map Marker
-
-```typescript
-interface MapMarker {
-  lat: number;
-  lng: number;
-  label?: string;
-  icon?: string;                  // Icon URL or name
-  popup?: string | ReactNode;
-  color?: string;                 // Marker color
-}
+```text
+TypeError [ERR_UNKNOWN_FILE_EXTENSION]: Unknown file extension ".css"
+  for .../maplibre-gl/dist/maplibre-gl.css
 ```
 
-## Examples
-
-### Basic Map
+**This is a supported-configuration statement, not a bug to report.** Unbundled Node
+consumption is not supported for style-carrying plugin packages. It was ruled that way on
+[objectui#5384](https://github.com/objectstack-ai/objectui/issues/5384) — deliberately, over
+the alternative of moving the stylesheet out of module scope — because a MapLibre canvas
+without its stylesheet is not a map, and no unbundled-Node consumer exists to serve.
 
-```typescript
-const schema = {
-  type: 'map',
-  center: { lat: 40.7128, lng: -74.0060 },
-  zoom: 13,
-  height: 500,
-  markers: [
-    {
-      lat: 40.7128,
-      lng: -74.0060,
-      label: 'New York City',
-      popup: 'The Big Apple'
-    }
-  ]
-};
-```
+Consume it through a host that handles CSS imports, which every supported host does: Vite,
+webpack, or Next with the package listed in `transpilePackages`. If you have a real need to
+import it under plain Node — SSR with no bundler, a Node-side script — please open an issue.
+That reopens the question as a design decision rather than a defect, and the shape of your
+consumer is the missing input.
 
-### Multiple Markers
+## Usage
 
-```typescript
-const schema = {
-  type: 'map',
-  center: { lat: 37.7749, lng: -122.4194 },
-  zoom: 10,
-  markers: [
-    {
-      lat: 37.7749,
-      lng: -122.4194,
-      label: 'San Francisco',
-      color: 'red',
-      popup: 'Golden Gate Bridge'
-    },
-    {
-      lat: 37.8044,
-      lng: -122.2712,
-      label: 'Oakland',
-      color: 'blue',
-      popup: 'Port of Oakland'
-    },
-    {
-      lat: 37.3382,
-      lng: -121.8863,
-      label: 'San Jose',
-      color: 'green',
-      popup: 'Silicon Valley'
-    }
-  ]
-};
-```
+Registration is a side effect of the import. There is no manual-registration
+export to iterate over — the import *is* the registration.
 
-### Interactive Map
+```ts
+import '@object-ui/plugin-map';
 
-```typescript
+// Object-bound: the markers are the records the query returns.
 const schema = {
-  type: 'map',
-  center: { lat: 51.5074, lng: -0.1278 },
-  zoom: 12,
-  markers: [/* markers */],
-  onMarkerClick: (marker) => {
-    console.log('Marker clicked:', marker);
-    // Show marker details
+  type: 'object-map',
+  objectName: 'stores',
+  map: {
+    latitudeField: 'lat',
+    longitudeField: 'lng',
+    titleField: 'name',
+    descriptionField: 'address',
   },
-  onMapClick: (coordinates) => {
-    console.log('Map clicked at:', coordinates);
-    // Add new marker
-  }
-};
-```
-
-### Map with Data Binding
-
-```typescript
-const schema = {
-  type: 'map',
-  center: { lat: 37.7749, lng: -122.4194 },
-  zoom: 10,
-  markers: '${data.locations.map(loc => ({ lat: loc.latitude, lng: loc.longitude, label: loc.name }))}',
-  onMarkerClick: (marker) => {
-    // Handle marker click
-  }
 };
 ```
 
-## Integration with ObjectQL
-
-Connect map to ObjectStack data sources:
-
-```typescript
-import { createObjectStackAdapter } from '@object-ui/data-objectstack';
-
-const dataSource = createObjectStackAdapter({
-  baseUrl: 'https://api.example.com',
-  token: 'your-auth-token'
-});
+A literal record array instead of a query, with the same `map` block:
 
+```ts
 const schema = {
   type: 'object-map',
-  dataSource,
-  object: 'locations',
-  latField: 'latitude',
-  lngField: 'longitude',
-  labelField: 'name',
-  popupField: 'description',
-  center: { lat: 37.7749, lng: -122.4194 },
-  zoom: 10
-};
-```
-
-## Map Features
-
-### Custom Markers
-
-```typescript
-const schema = {
-  type: 'map',
-  markers: [
-    {
-      lat: 40.7128,
-      lng: -74.0060,
-      icon: '/custom-marker.png',
-      popup: {
-        type: 'card',
-        title: 'Location Details',
-        body: 'Custom popup content'
-      }
-    }
-  ]
-};
-```
-
-### Geolocation
-
-```typescript
-const schema = {
-  type: 'map',
-  useGeolocation: true,           // Center map on user's location
-  zoom: 15,
-  markers: []
+  staticData: [
+    { id: 1, name: 'San Francisco HQ', lat: 37.7749, lng: -122.4194 },
+    { id: 2, name: 'Oakland Office', lat: 37.8044, lng: -122.2711 },
+  ],
+  map: { latitudeField: 'lat', longitudeField: 'lng', titleField: 'name' },
 };
 ```
 
-### Map Layers
-
-```typescript
-const schema = {
-  type: 'map',
-  center: { lat: 37.7749, lng: -122.4194 },
-  layers: [
-    { type: 'heatmap', data: [/* heatmap data */] },
-    { type: 'polygon', coordinates: [/* polygon coordinates */], color: 'rgba(255, 0, 0, 0.3)' }
-  ]
-};
+`filter` and `sort` are the **query's** filter and order — they reach the data
+source as `$filter` / `$orderby`, and the spec's per-element `dataSource` binding
+is honoured as well. The map issues no row cap of its own.
+
+## The `map` block
+
+The declared configuration input. Every key is optional:
+
+| Key | Description |
+| --- | --- |
+| `latitudeField` | Record field holding the latitude. Needs `longitudeField` alongside it; both values must be numbers. |
+| `longitudeField` | Record field holding the longitude. |
+| `locationField` | Single field holding both coordinates — see the formats below. Used when the lat/lng pair yields nothing. |
+| `titleField` | Field shown as the marker title. Omitted, markers are titled `Marker`. |
+| `descriptionField` | Field shown under the title in the marker popup. |
+| `zoom` | Zoom level. Declaring it opts this view out of the auto-fit (see below). |
+| `center` | `[latitude, longitude]` — a two-number **tuple**, latitude first. Declaring it opts this view out of the auto-fit. |
+| `style` | MapLibre style URL/spec, replacing the default public demo style. |
+
+**The block replaces the field-name defaults, it is not merged with them.** With
+no map configuration at all the component falls back to the field names
+`latitude` / `longitude` / `location` / `name` / `description`; the moment a `map`
+block is present, only what it declares is read. So `map: { titleField: 'name' }`
+on its own names no coordinate field, places nothing, and renders an empty map
+under the excluded-records notice — the defaults do not fill the gap.
+
+## Initial camera
+
+There is no default zoom and no default centre. With records to show and no
+camera declared, the map **fits the records**: their bounding box, measured along
+the shortest arc that contains them (so a set straddling the antimeridian is
+framed across the line, not around the far side of the planet), with 48px of
+padding and a city-scale zoom ceiling of 12 — a single record does not become a
+rooftop view.
+
+Two cases sit outside the fit:
+
+- **Nothing placeable** (empty result, or no record yielding coordinates): the
+  whole world, centred on `0, 0`.
+- **A declared camera**: `zoom` or `center` in the `map` block wins and the fit is
+  skipped. Declaring one half keeps the other derived — `zoom` alone is applied at
+  the centre of the records, `center` alone at a continental zoom.
+
+A `center` that is not a two-number tuple (the `{ lat, lng }` object form, say) is
+rejected by the config schema, warned about in the console, and **not** adapted —
+and it does not cost the view its fit.
+
+## Coordinate formats
+
+`locationField` reads any of:
+
+```ts
+{ location: { lat: 37.7749, lng: -122.4194 } }  // also latitude/longitude, lon
+{ location: '37.7749,-122.4194' }               // "lat,lng"
+{ location: [37.7749, -122.4194] }              // [lat, lng]
 ```
 
-## TypeScript Support
+A record whose coordinates are missing, unparseable, or out of range (latitude
+beyond ±90, longitude beyond ±180) is left off the map and counted in a notice
+above it, rather than being silently dropped or rescued.
 
-```typescript
-import type { MapSchema, MapMarker } from '@object-ui/plugin-map';
+## What this component does not read
 
-const marker: MapMarker = {
-  lat: 37.7749,
-  lng: -122.4194,
-  label: 'San Francisco',
-  color: 'red'
-};
+Keys that look plausible on a map schema but have no read site here: `markers`
+(markers are records), `layers`, `height` (the container is a fixed responsive
+height, 300px through 600px), `useGeolocation` (the map carries a
+user-initiated "show my location" button instead), and per-marker `icon` /
+`color` / `popup` styling. A `map` configuration stashed under `filter.map` — a
+shape predating the `map` input — is no longer read either, and says so in the
+console.
 
-const map: MapSchema = {
-  type: 'map',
-  center: { lat: 37.7749, lng: -122.4194 },
-  zoom: 12,
-  markers: [marker]
-};
-```
+## Using `ObjectMap` directly
 
-## Customization
+`ObjectMap` (the component), `ObjectMapRenderer` (the registered wrapper, for a
+host that registers types itself) and the `ObjectMapProps` type are the package's
+exports:
 
-Style the map with Tailwind classes:
+```tsx
+import { ObjectMap } from '@object-ui/plugin-map';
 
-```typescript
-const schema = {
-  type: 'map',
-  className: 'rounded-lg shadow-xl border-2 border-gray-200',
-  height: '600px',
-  center: { lat: 37.7749, lng: -122.4194 }
-};
+<ObjectMap
+  schema={{ type: 'object-map', objectName: 'stores', map: { latitudeField: 'lat', longitudeField: 'lng' } }}
+  dataSource={dataSource}
+  onMarkerClick={(record) => console.log(record)}
+/>;
 ```
 
-<!-- release-metadata:v3.3.0 -->
-
-## Compatibility
-
-- **React:** 18.x or 19.x
-- **Node.js:** ≥ 18
-- **TypeScript:** ≥ 5.0 (strict mode)
-- **`@objectstack/spec`:** ^3.3.0
-- **`@objectstack/client`:** ^3.3.0
-- **Tailwind CSS:** ≥ 3.4 (for packages with UI)
+| Prop | Description |
+| --- | --- |
+| `schema` | The map schema — the keys above. |
+| `dataSource` | Resolves the `object` provider. Not needed for `staticData` or an inline `data` array. |
+| `className` | Classes for the wrapper around the map. |
+| `data` | Records to render directly, bypassing the component's own fetch — the shape `ListView` passes when it already holds the rows. Tracked live: passing a new array after mount (e.g. once a host's own in-flight query resolves) updates the map. |
+| `onMarkerClick` | Called with the clicked record. |
+| `onRowClick` | Record click handler; takes priority over the `navigation` overlay. |
+| `onEdit` / `onDelete` | Passing either adds that button to the marker popup (and to the mobile record sheet). |
+| `enableClustering` | Forces clustering on; without it, clustering starts above 100 visible markers. |
+| `clusterRadius` | Clustering granularity (default `50`): the grid cell is `clusterRadius / 2 ** zoom`, so a larger value groups more aggressively. |
+
+In a schema-driven page these handlers may equally be authored on the node
+itself: `SchemaRenderer` spreads a node's non-metadata properties onto the
+component.
 
 ## Links
 
-- 📚 [Documentation](https://www.objectui.org/docs/plugins/plugin-map)
+- 📚 [Documentation](https://www.objectui.org/docs/plugins/plugin-map) — the full
+  authoring reference for the schema and the `map` block
 - 📦 [npm package](https://www.npmjs.com/package/@object-ui/plugin-map)
 - 📝 [Changelog](./CHANGELOG.md)
 - 🐛 [Report an issue](https://github.com/objectstack-ai/objectui/issues)

package/dist/ObjectMap.d.ts

@@ -1,16 +1,31 @@
 import { default as React } from 'react';
-import { ObjectGridSchema, DataSource } from '@object-ui/types';
+import { ObjectMapSchema, DataSource } from '@object-ui/types';
 export interface ObjectMapProps {
-    schema: ObjectGridSchema;
+    schema: ObjectMapSchema;
     dataSource?: DataSource;
     className?: string;
+    /**
+     * Records to render directly, bypassing this component's own fetch — the
+     * shape `ListView` passes when it already holds the rows. Declared as its
+     * own prop (not read off the `rest` spread) so the fetch effect can depend
+     * on this one value: naming the whole `rest` object in that effect's deps
+     * instead would refetch on every render, since `rest` is a fresh object
+     * each render (objectui#5003).
+     */
+    data?: any[];
     onMarkerClick?: (record: any) => void;
     onRowClick?: (record: any) => void;
     onEdit?: (record: any) => void;
     onDelete?: (record: any) => void;
     /** Enable marker clustering for dense data */
     enableClustering?: boolean;
-    /** Cluster radius in pixels (default: 50) */
+    /**
+     * Clustering grid granularity (default: 50). NOT screen pixels — the grid
+     * cell edge is `clusterRadius / 2 ** zoom`, in coordinate DEGREES (the
+     * marker's `[lng, lat]`), so a larger value groups more aggressively and
+     * the effective granularity shrinks exponentially as zoom increases. See
+     * `clusterMarkers` below.
+     */
     clusterRadius?: number;
 }
 export declare const ObjectMap: React.FC<ObjectMapProps>;

package/dist/ObjectMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObjectMap.d.ts","sourceRoot":"","sources":["../src/ObjectMap.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AAEH,OAAO,KAA4D,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAY,MAAM,kBAAkB,CAAC;AAO/E,OAAO,kCAAkC,CAAC;AAqB1C,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACjC,8CAA8C;IAC9C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,6CAA6C;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAkPD,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CA4d9C,CAAC;AAEF,eAAe,SAAS,CAAC"}
+{"version":3,"file":"ObjectMap.d.ts","sourceRoot":"","sources":["../src/ObjectMap.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AAEH,OAAO,KAA4D,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAmB,UAAU,EAAY,MAAM,kBAAkB,CAAC;AAY/F,OAAO,kCAAkC,CAAC;AAkB1C,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACjC,8CAA8C;IAC9C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAkcD,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CA2jB9C,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/camera.d.ts

@@ -0,0 +1,102 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Initial-camera derivation for ObjectMap (objectui#4941).
+ *
+ * A map view whose query returned records must never first-paint an empty
+ * viewport. The camera is therefore derived from the records themselves: the
+ * marker set's bounding box, handed to MapLibre so it fits the box with the
+ * real container size (`initialViewState.bounds` -> the `bounds` /
+ * `fitBoundsOptions` pair on the MapLibre `Map` constructor, which overrides
+ * `center` / `zoom`).
+ *
+ * Two things this module deliberately does NOT do:
+ *
+ * 1. It does not rescue out-of-range record coordinates. The platform's
+ *    `location` value is `{ lat, lng }` with longitude bounded to [-180, 180]
+ *    by `@objectstack/spec` (`data/field-value.zod.ts`), so a longitude outside
+ *    that range is a producer-side defect, not a dialect this renderer should
+ *    learn to read. `ObjectMap` keeps rejecting such records and counting them
+ *    in its "invalid coordinates" notice. The normalization here is projection
+ *    arithmetic over already-valid values, applied to the CAMERA only.
+ * 2. It does not introduce any authoring surface. The only camera declaration
+ *    read anywhere is the documented `zoom` / `center` pair of the map config
+ *    block (`content/docs/plugins/plugin-map.mdx`), and an author who declares
+ *    it keeps winning over everything computed here.
+ */
+/**
+ * `[[west, south], [east, north]]` — the two-corner form MapLibre accepts as
+ * `LngLatBoundsLike`. `east` may exceed 180: that is how MapLibre expects a box
+ * crossing the antimeridian to be spelled (its own `adjustAntiMeridian` produces
+ * exactly this shape), and it is what keeps the fitted camera on the same world
+ * copy as the markers.
+ */
+export type MarkerBounds = [[number, number], [number, number]];
+/** Breathing room around the fitted box, in pixels. */
+export declare const FIT_PADDING_PX = 48;
+/**
+ * Ceiling for the fitted zoom. A single record — or several records at one
+ * address — fits a zero-width box, and an unbounded fit answers that with the
+ * map's maximum zoom (22): a building-level view of a style whose tiles usually
+ * stop far short of it. City scale is the useful answer instead.
+ */
+export declare const FIT_MAX_ZOOM = 12;
+/** Zoom used when there is nothing to fit: the whole world, not a random sea. */
+export declare const EMPTY_VIEW_ZOOM = 2;
+/**
+ * Zoom used when a partially declared camera pins the position but not the
+ * scale, so the box cannot drive the fit. Same value the component used before
+ * the fit existed.
+ */
+export declare const UNFITTED_CENTER_ZOOM = 3;
+/**
+ * Latitude ceiling for the fitted box. Web Mercator is unbounded at the poles,
+ * so a record sitting exactly at +/-90 projects to infinity and takes the whole
+ * camera with it. Markers themselves stay at their real latitude.
+ */
+export declare const MAX_FIT_LATITUDE = 85;
+/**
+ * Fold any longitude onto the [-180, 180) circle.
+ *
+ * In-range values return unchanged rather than through the modulo, which would
+ * round-trip them into a neighbouring float (-74.006 came back as
+ * -74.00599999999997) and put that drift into every fitted box.
+ */
+export declare function normalizeLongitude(lng: number): number;
+/**
+ * Bounding box of a marker set, along the SHORTEST arc that contains every
+ * marker.
+ *
+ * Why the shortest arc and not `[min(lng), max(lng)]`: the naive extremes read
+ * the circle as a line, so a set straddling the antimeridian (say 179 and -179,
+ * two degrees apart) yields a 358-degree-wide box whose midpoint is 0 — the
+ * antipode of the data, half a planet away. MapLibre then places the markers in
+ * whichever world copy is nearest their previous screen position (`smartWrap`),
+ * which is how a fitted-looking camera ends up showing an empty ocean with the
+ * records sitting on a neighbouring copy of the world.
+ *
+ * The widest EMPTY gap between adjacent longitudes is the seam to cut; what
+ * remains is the shortest containing arc. `west` is the first marker east of
+ * that seam, and the span is measured eastward from it, so the box may extend
+ * past 180.
+ *
+ * @param coordinates marker coordinates in MapLibre order, `[lng, lat]`
+ * @returns the box, or `null` when there is nothing to fit
+ */
+export declare function computeMarkerBounds(coordinates: ReadonlyArray<readonly [number, number]>): MarkerBounds | null;
+/**
+ * Centre of a box from {@link computeMarkerBounds}, for the paths that cannot
+ * hand the box to a fit (a declared zoom with no declared centre). The
+ * longitude is folded back onto the circle so a box crossing the antimeridian
+ * still yields a real centre rather than a value past 180.
+ */
+export declare function boundsCenter(bounds: MarkerBounds): {
+    longitude: number;
+    latitude: number;
+};
+//# sourceMappingURL=camera.d.ts.map

package/dist/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAEhE,uDAAuD;AACvD,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,iFAAiF;AACjF,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGtD;AAKD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACpD,YAAY,GAAG,IAAI,CA8BrB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAM1F"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,CAAC;AAG/B,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAG3C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAO1B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,CAAC;AAwB/B,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAgB3C,CAAC"}