@goway.to/maps 0.0.0-stage → 0.1.0

package/NOTICE

@@ -0,0 +1,25 @@
+============================================================================
+ NOTICE
+ OxyHQ/GoWay — the @goway.to/sdk package
+ Copyright (c) 2026-present The Oxy Collective, Inc.
+============================================================================
+
+This product is licensed under the Breathe License 1.0, license identifier
+LicenseRef-Breathe-1.0. See the LICENSE file. Commercial terms are available
+at https://github.com/OxyHQ/.github/blob/main/LICENSE-COMMERCIAL.md
+
+Attribution under Section 3.1 of the Breathe License is required of
+everyone, including paying commercial licensees, and cannot be waived.
+
+----------------------------------------------------------------------------
+ THIRD PARTY COMPONENTS
+----------------------------------------------------------------------------
+
+This repository contains no vendored third party source. Its dependencies
+are resolved and installed by the package manager and remain governed by
+their own licenses.
+
+This work must not take on a GPL or AGPL dependency that is linked in
+process: the Breathe License is not compatible with either, in either
+direction. If you are adding one, stop and read
+https://github.com/OxyHQ/.github/blob/main/licensing/README.md

package/README.md

@@ -1,3 +1,60 @@
-# Temporary Holding Version
+# `@goway.to/maps`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+GoWay's maps SDK for React and React Native: one declarative map for the web
+(MapLibre GL JS) and iOS/Android (MapLibre Native), drawn in GoWay's styles.
+
+```bash
+bun add @goway.to/maps @goway.to/sdk maplibre-gl @maplibre/maplibre-react-native
+```
+
+```tsx
+import { MapView, Markers, UserLocation, type MapViewRef } from '@goway.to/maps';
+
+<MapView
+  ref={mapRef}
+  mapStyle="goway://styles/standard"      // the default; day in light mode, night in dark
+  camera={{ bounds: searchedArea }}        // framed whenever its VALUE changes
+  onCameraChanged={({ bounds, source, isFinal }) => …}
+  onPress={({ coordinate, label }) => …}
+>
+  <Markers data={homes} selectedId={selected} cluster onPress={(home) => …} />
+  <UserLocation />
+</MapView>
+```
+
+- **Markers** are Bloom's (`@oxy.so/bloom/map-marker`) on both platforms, and
+  cluster with Mapbox's source options (`cluster`, `clusterRadius`,
+  `clusterMaxZoom`).
+- **The camera** opens on `initialViewState` and follows `camera` by value, so
+  a re-render never moves it under a reader who has panned; the ref
+  (`fitBounds`, `moveTo`, …) is for event handlers.
+- **User location** is drawn only against a permission already granted;
+  `useUserLocation()` asks, from a tap.
+- Every map carries the GoWay mark and the data credit, with no prop to turn
+  either off.
+
+## Setup
+
+- **Native**: add the config plugin (`plugins: ['@goway.to/maps']` in
+  `app.config.js`) and make a development or store build — MapLibre Native is
+  not in Expo Go.
+- **Web with Metro (Expo)**: wrap the Metro config, which serves MapLibre's
+  worker from your origin (`maplibre-gl` 6 starts it by URL), and gitignore
+  `public/vendor/`:
+
+  ```js
+  const { withGoWayMaps } = require('@goway.to/maps/metro');
+  module.exports = withGoWayMaps(getDefaultConfig(__dirname));
+  ```
+
+- Render inside Bloom's `BloomProvider`: the map follows its theme and locale.
+
+## Entry points
+
+| import | what |
+| --- | --- |
+| `@goway.to/maps` | `MapView`, `Markers`, `GeoJSONSource`, `RasterDEMSource`, `Layer`, `UserLocation`, `MapPlugin`, `useMap`, `useUserLocation` |
+| `@goway.to/maps/plugin` | the engine-plugin protocol and the guards every coordinate crossing into an engine goes through (no React) |
+| `@goway.to/maps/testing` | a fake engine that drives the map's real camera reports, for testing a screen's camera logic |
+| `@goway.to/maps/brand` | the GoWay mark as geometry |
+| `@goway.to/maps/metro`, `@goway.to/maps/app.plugin.js` | the Metro helper and the Expo config plugin |

package/app.plugin.js

@@ -0,0 +1,19 @@
+/**
+ * `@goway.to/maps` Expo config plugin: adds MapLibre Native to a development
+ * or store build (it is absent from Expo Go).
+ *
+ *     // app.config.js
+ *     plugins: ['@goway.to/maps']
+ *
+ * It applies `@maplibre/maplibre-react-native`'s own plugin, so an app names
+ * one map package in its config, as with `@rnmapbox/maps`. The location usage
+ * strings stay the app's (`expo-location`'s plugin): only the app knows why it
+ * asks.
+ */
+// The package exports its plugin as an ES module's default.
+const loaded = require('@maplibre/maplibre-react-native/app.plugin.js');
+const maplibre = typeof loaded === 'function' ? loaded : loaded.default;
+
+module.exports = function withGoWayMaps(config, options = {}) {
+  return maplibre(config, options);
+};

package/dist/CameraBinding.web.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `MapView`'s `camera` target, web — framed whenever its VALUE changes.
+ *
+ * The camera is an imperative object behind maplibre-gl's `fitBounds`, and a
+ * target that changes because the app's state changed — a place picked, a URL
+ * arriving, back and forward — comes with no event this map handles. So the
+ * one binding below applies it, keyed on the four numbers of the box (or the
+ * point and zoom), never on the object: a re-render with an equal target does
+ * nothing, and the map never moves under a reader who has panned.
+ *
+ * The first target is JUMPED to — the map opens on it. A later change
+ * animates over `duration`. An engine rebuilt for a new style keeps the
+ * camera it had, so an unchanged target is not applied to it again: changing
+ * the map's look never moves the map.
+ */
+import { type RefObject } from 'react';
+import type { Map as MapLibreMap } from 'maplibre-gl';
+import type { MapCameraTarget } from './types';
+export declare function CameraBinding({ map, target, applied, }: {
+    map: MapLibreMap;
+    target: MapCameraTarget;
+    /** The target last applied, on ANY engine of this map — owned by `MapView`, which outlives them. */
+    applied: RefObject<string | null>;
+}): null;

package/dist/CameraBinding.web.js

@@ -0,0 +1,46 @@
+/**
+ * `MapView`'s `camera` target, web — framed whenever its VALUE changes.
+ *
+ * The camera is an imperative object behind maplibre-gl's `fitBounds`, and a
+ * target that changes because the app's state changed — a place picked, a URL
+ * arriving, back and forward — comes with no event this map handles. So the
+ * one binding below applies it, keyed on the four numbers of the box (or the
+ * point and zoom), never on the object: a re-render with an equal target does
+ * nothing, and the map never moves under a reader who has panned.
+ *
+ * The first target is JUMPED to — the map opens on it. A later change
+ * animates over `duration`. An engine rebuilt for a new style keeps the
+ * camera it had, so an unchanged target is not applied to it again: changing
+ * the map's look never moves the map.
+ */
+import { useLayoutEffect } from 'react';
+import { cameraTargetKey } from './cameraTarget';
+import { createWebMapApi } from './commands.web';
+export function CameraBinding({ map, target, applied, }) {
+    const { bounds, center, zoom, padding, maxZoom, duration } = target;
+    const key = cameraTargetKey({ bounds, center, zoom });
+    // Binding: the engine's camera follows the VALUE of `camera` (`key`).
+    // biome-ignore lint/correctness/useExhaustiveDependencies: `key` is the value the target stands for; a new object with the same numbers must not move the camera
+    useLayoutEffect(() => {
+        if (key === null || key === applied.current)
+            return;
+        const first = applied.current === null;
+        applied.current = key;
+        const api = createWebMapApi(() => map);
+        const time = first ? 0 : duration;
+        if (bounds) {
+            api.fitBounds(bounds, {
+                ...(padding !== undefined ? { padding } : {}),
+                ...(maxZoom !== undefined ? { maxZoom } : {}),
+                ...(time !== undefined ? { duration: time } : {}),
+            });
+        }
+        else if (center) {
+            api.moveTo(center, {
+                ...(zoom !== undefined ? { zoom } : {}),
+                ...(time !== undefined ? { duration: time } : {}),
+            });
+        }
+    }, [map, key]);
+    return null;
+}

package/dist/DefaultMapMarker.d.ts

@@ -0,0 +1,8 @@
+import type { MapMarkerItem } from './types';
+export interface DefaultMapMarkerProps {
+    item: MapMarkerItem;
+    onPress?: () => void;
+}
+declare function DefaultMapMarkerComponent({ item, onPress }: DefaultMapMarkerProps): import("react").JSX.Element;
+export declare const DefaultMapMarker: import("react").MemoExoticComponent<typeof DefaultMapMarkerComponent>;
+export {};

package/dist/DefaultMapMarker.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The marker body both forks draw when a caller does not pass `renderMarker`.
+ *
+ * These are Bloom components, not GoWay ones: `@oxy.so/bloom/map-marker`
+ * already ships the pill and the cluster bubble with their `default` /
+ * `active` / `visited` states, their press affordance and their web focus
+ * ring, so a local marker would be a second, worse copy that drifts from the
+ * design system at the first token change.
+ *
+ * Because it is ordinary Bloom UI on both platforms (native positions it with
+ * MapLibre's `<Marker>`, web with a DOM `maplibregl.Marker` it is portalled
+ * into), a marker looks identical on iOS, Android and the web.
+ */
+import { memo } from 'react';
+import { MapClusterMarker, MapPriceMarker } from '@oxy.so/bloom/map-marker';
+function DefaultMapMarkerComponent({ item, onPress }) {
+    if (item.kind === 'cluster') {
+        return (_jsx(MapClusterMarker, { count: item.cluster.count, state: item.state, onPress: onPress, testID: `map-cluster-${item.cluster.id}` }));
+    }
+    const { marker } = item;
+    return (_jsx(MapPriceMarker
+    // Bloom's pill is a labelled marker; the label happens to be a price in
+    // its first consumer. GoWay passes a place name, a category or nothing.
+    , { 
+        // Bloom's pill is a labelled marker; the label happens to be a price in
+        // its first consumer. GoWay passes a place name, a category or nothing.
+        price: marker.label ?? '•', state: item.state, size: marker.label ? 'default' : 'compact', onPress: onPress, accessibilityLabel: marker.accessibilityLabel ?? marker.label ?? 'Map marker', testID: `map-marker-${marker.id}` }));
+}
+export const DefaultMapMarker = memo(DefaultMapMarkerComponent);

package/dist/GeoJSONSource.d.ts

@@ -0,0 +1,2 @@
+import type { GeoJSONSourceProps } from './types';
+export declare function GeoJSONSource({ id, data, cluster, clusterRadius, clusterMaxZoom, clusterMinPoints, clusterProperties, children, }: GeoJSONSourceProps): import("react").JSX.Element;

package/dist/GeoJSONSource.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { GeoJSONSource as NativeGeoJSONSource } from '@maplibre/maplibre-react-native';
+import { isDrawableGeoJSON, reportMapDefect } from './shared';
+import { SourceIdContext } from './sourceContext';
+const EMPTY = { type: 'FeatureCollection', features: [] };
+export function GeoJSONSource({ id, data, cluster, clusterRadius, clusterMaxZoom, clusterMinPoints, clusterProperties, children, }) {
+    // Raw GeoJSON fails SILENTLY rather than loudly: refused here, and said so.
+    const drawable = isDrawableGeoJSON(data);
+    if (!drawable) {
+        reportMapDefect(`source:${id}`, `Dropped the data of source "${id}": it is not drawable GeoJSON.`);
+    }
+    return (_jsx(NativeGeoJSONSource, { id: id, data: drawable ? data : EMPTY, ...(cluster ? { cluster: true } : {}), ...(clusterRadius !== undefined ? { clusterRadius } : {}), ...(clusterMaxZoom !== undefined ? { clusterMaxZoom } : {}), ...(clusterMinPoints !== undefined ? { clusterMinPoints } : {}), ...(clusterProperties
+            ? {
+                clusterProperties: clusterProperties,
+            }
+            : {}), children: _jsx(SourceIdContext.Provider, { value: id, children: children }) }));
+}

package/dist/GeoJSONSource.web.d.ts

@@ -0,0 +1,2 @@
+import type { GeoJSONSourceProps } from './types';
+export declare function GeoJSONSource(props: GeoJSONSourceProps): import("react").JSX.Element | null;

package/dist/GeoJSONSource.web.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * `<GeoJSONSource>`, web — a GeoJSON source on the engine, with `<Layer>`
+ * children drawing it.
+ *
+ * Two bindings, in two files, because a source has two lives: it is ADDED
+ * once per engine (here, with its clustering options, which maplibre-gl takes
+ * only at creation) and its DATA changes many times (`SourceData.web.tsx`,
+ * `setData`). Removing and re-adding it for every new data set would take its
+ * layers with it.
+ *
+ * The layers render only once the source exists: React binds children before
+ * their parent, and a layer added before its source throws.
+ */
+import { useContext, useLayoutEffect, useState } from 'react';
+import { WebEngineContext } from './engineContext.web';
+import { isDrawableGeoJSON, reportMapDefect, runEngineCommand } from './shared';
+import { SourceIdContext } from './sourceContext';
+import { SourceData } from './SourceData.web';
+const EMPTY = { type: 'FeatureCollection', features: [] };
+export function GeoJSONSource(props) {
+    const engine = useContext(WebEngineContext);
+    return engine ? _jsx(GeoJSONSourceBinding, { map: engine.map, ...props }) : null;
+}
+function GeoJSONSourceBinding({ map, id, data, cluster, clusterRadius, clusterMaxZoom, clusterMinPoints, clusterProperties, children, }) {
+    const [added, setAdded] = useState(null);
+    // Binding: the source `id` exists on the engine, with its creation options.
+    useLayoutEffect(() => {
+        const spec = {
+            type: 'geojson',
+            data: EMPTY,
+            ...(cluster ? { cluster: true } : {}),
+            ...(clusterRadius !== undefined ? { clusterRadius } : {}),
+            ...(clusterMaxZoom !== undefined ? { clusterMaxZoom } : {}),
+            ...(clusterMinPoints !== undefined ? { clusterMinPoints } : {}),
+            ...(clusterProperties
+                ? {
+                    clusterProperties: clusterProperties,
+                }
+                : {}),
+        };
+        if (!runEngineCommand('addSource', () => map.addSource(id, spec)))
+            return;
+        setAdded(map);
+        return () => {
+            setAdded(null);
+            runEngineCommand('removeSource', () => {
+                // A layer still drawing the source would make the removal throw.
+                for (const layer of map.getStyle()?.layers ?? []) {
+                    if ('source' in layer && layer.source === id)
+                        map.removeLayer(layer.id);
+                }
+                if (map.getSource(id))
+                    map.removeSource(id);
+            });
+        };
+    }, [map, id, cluster, clusterRadius, clusterMaxZoom, clusterMinPoints, clusterProperties]);
+    if (added !== map)
+        return null;
+    // Raw GeoJSON fails SILENTLY rather than loudly: a NaN vertex tiles to
+    // nothing and the line the reader asked for is simply absent. Refused here,
+    // and said so.
+    const drawable = isDrawableGeoJSON(data);
+    if (!drawable) {
+        reportMapDefect(`source:${id}`, `Dropped the data of source "${id}": it is not drawable GeoJSON.`);
+    }
+    return (_jsxs(SourceIdContext.Provider, { value: id, children: [_jsx(SourceData, { map: map, id: id, data: drawable ? data : EMPTY }), children] }));
+}

package/dist/InteractionBinding.web.d.ts

@@ -0,0 +1,7 @@
+import type { Map as MapLibreMap } from 'maplibre-gl';
+import type { MapInteractionOptions } from './types';
+export declare function InteractionBinding({ map, interaction, maxPitch, }: {
+    map: MapLibreMap;
+    interaction: MapInteractionOptions | undefined;
+    maxPitch: number;
+}): null;

package/dist/InteractionBinding.web.js

@@ -0,0 +1,35 @@
+/**
+ * The engine's gesture handlers and pitch ceiling, bound to `interaction` and
+ * `maxPitch`.
+ *
+ * maplibre-gl toggles gestures with imperative `enable()`/`disable()` calls on
+ * its handlers, so this component holds the one binding that keeps them equal
+ * to the props. Every flag is independent, on web as on native: `rotate` and
+ * `pitch` are separate axes even though MapLibre drives both from one desktop
+ * handler (`dragAxes.web.ts`).
+ */
+import { useLayoutEffect } from 'react';
+import { applyDragAxes } from './dragAxes.web';
+import { resolveInteraction, runEngineCommand } from './shared';
+export function InteractionBinding({ map, interaction, maxPitch, }) {
+    const { pan, zoom, rotate, pitch } = resolveInteraction(interaction);
+    // Binding: the engine's gesture handlers follow `interaction` and `maxPitch`.
+    useLayoutEffect(() => {
+        const toggle = (handler, on) => on ? handler.enable() : handler.disable();
+        runEngineCommand('interaction', () => {
+            toggle(map.dragPan, pan);
+            toggle(map.scrollZoom, zoom);
+            toggle(map.touchZoomRotate, zoom);
+            toggle(map.doubleClickZoom, zoom);
+            if (rotate)
+                map.touchZoomRotate.enableRotation();
+            else
+                map.touchZoomRotate.disableRotation();
+            applyDragAxes(map.dragRotate, { rotate, pitch });
+            toggle(map.touchPitch, pitch);
+            // The backstop: with pitch off no path can tilt the camera.
+            map.setMaxPitch(pitch ? maxPitch : 0);
+        });
+    }, [map, pan, zoom, rotate, pitch, maxPitch]);
+    return null;
+}

package/dist/Layer.d.ts

@@ -0,0 +1,2 @@
+import type { LayerProps } from './types';
+export declare function Layer({ id, type, paint, layout, filter, beforeId, minzoom, maxzoom }: LayerProps): import("react").JSX.Element;

package/dist/Layer.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Layer as NativeLayer } from '@maplibre/maplibre-react-native';
+import { useSourceId } from './sourceContext';
+export function Layer({ id, type, paint, layout, filter, beforeId, minzoom, maxzoom }) {
+    const source = useSourceId();
+    const props = {
+        id,
+        type,
+        source,
+        ...(paint ? { paint } : {}),
+        ...(layout ? { layout } : {}),
+        ...(filter ? { filter } : {}),
+        ...(beforeId ? { beforeId } : {}),
+        ...(minzoom !== undefined ? { minzoom } : {}),
+        ...(maxzoom !== undefined ? { maxzoom } : {}),
+    };
+    // MapLibre Native types a layer as a union keyed by `type`; a `<Layer>`
+    // takes its type as a value and its properties as plain style-spec names,
+    // which the engine validates itself.
+    return _jsx(NativeLayer, { ...props });
+}

package/dist/Layer.web.d.ts

@@ -0,0 +1,2 @@
+import type { LayerProps } from './types';
+export declare function Layer(props: LayerProps): import("react").JSX.Element | null;

package/dist/Layer.web.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * `<Layer>`, web — a style layer drawing the source around it.
+ *
+ * Added once per engine with what maplibre-gl fixes at creation (its id,
+ * type, source and place in the stack); its paint, layout and filter are
+ * their own binding (`LayerStyle.web.tsx`), so a new colour restyles the layer
+ * instead of removing and re-adding it.
+ */
+import { useContext, useLayoutEffect, useState } from 'react';
+import { WebEngineContext } from './engineContext.web';
+import { LayerStyle } from './LayerStyle.web';
+import { runEngineCommand } from './shared';
+import { useSourceId } from './sourceContext';
+export function Layer(props) {
+    const engine = useContext(WebEngineContext);
+    const source = useSourceId();
+    return engine ? _jsx(LayerBinding, { map: engine.map, source: source, ...props }) : null;
+}
+function LayerBinding({ map, source, id, type, beforeId, minzoom, maxzoom, paint, layout, filter, }) {
+    const [added, setAdded] = useState(null);
+    // Binding: the layer `id` exists on the engine, over `source`, under `beforeId`.
+    useLayoutEffect(() => {
+        const spec = {
+            id,
+            type,
+            source,
+            ...(minzoom !== undefined ? { minzoom } : {}),
+            ...(maxzoom !== undefined ? { maxzoom } : {}),
+        };
+        // Under `beforeId` only when the style has it: a style that makes no such
+        // promise gets the layer on top rather than an exception.
+        const before = beforeId && map.getLayer(beforeId) ? beforeId : undefined;
+        if (!runEngineCommand('addLayer', () => map.addLayer(spec, before)))
+            return;
+        setAdded(map);
+        return () => {
+            setAdded(null);
+            runEngineCommand('removeLayer', () => {
+                if (map.getLayer(id))
+                    map.removeLayer(id);
+            });
+        };
+    }, [map, source, id, type, beforeId, minzoom, maxzoom]);
+    return added === map ? (_jsx(LayerStyle, { map: map, id: id, paint: paint, layout: layout, filter: filter })) : null;
+}

package/dist/LayerStyle.web.d.ts

@@ -0,0 +1,10 @@
+import type { Map as MapLibreMap } from 'maplibre-gl';
+type Properties = Readonly<Record<string, unknown>>;
+export declare function LayerStyle({ map, id, paint, layout, filter, }: {
+    map: MapLibreMap;
+    id: string;
+    paint?: Properties;
+    layout?: Properties;
+    filter?: readonly unknown[];
+}): null;
+export {};

package/dist/LayerStyle.web.js

@@ -0,0 +1,45 @@
+/**
+ * A layer's paint, layout and filter, bound to its props with maplibre-gl's
+ * imperative setters (see `Layer.web.tsx` for why it is its own binding).
+ * A property the props drop is reset to the style default.
+ */
+import { useLayoutEffect, useRef } from 'react';
+import { runEngineCommand } from './shared';
+const NONE = {};
+export function LayerStyle({ map, id, paint = NONE, layout = NONE, filter, }) {
+    // What this binding last set on THIS engine's layer; a rebuilt engine's
+    // layer starts from the style's defaults.
+    const applied = useRef({
+        map: null,
+        paint: NONE,
+        layout: NONE,
+    });
+    // Binding: the layer's paint, layout and filter follow the props.
+    useLayoutEffect(() => {
+        const previous = applied.current.map === map ? applied.current : { map, paint: NONE, layout: NONE };
+        runEngineCommand('setLayerStyle', () => {
+            for (const key of new Set([...Object.keys(previous.paint), ...Object.keys(paint)])) {
+                if (previous.paint[key] !== paint[key])
+                    setPaint(map, id, key, paint[key]);
+            }
+            for (const key of new Set([...Object.keys(previous.layout), ...Object.keys(layout)])) {
+                if (previous.layout[key] !== layout[key])
+                    setLayout(map, id, key, layout[key]);
+            }
+            map.setFilter(id, (filter ?? null));
+        });
+        applied.current = { map, paint, layout };
+    }, [map, id, paint, layout, filter]);
+    return null;
+}
+/**
+ * maplibre-gl types a property NAME by the layer type it belongs to; a
+ * `<Layer>` names its properties in plain style-spec strings, which the
+ * engine validates itself (an unknown name is reported, not thrown).
+ */
+function setPaint(map, id, name, value) {
+    map.setPaintProperty.call(map, id, name, value);
+}
+function setLayout(map, id, name, value) {
+    map.setLayoutProperty.call(map, id, name, value);
+}

package/dist/LightBinding.web.d.ts

@@ -0,0 +1,5 @@
+import type { Map as MapLibreMap } from 'maplibre-gl';
+export declare function LightBinding({ map, light, }: {
+    map: MapLibreMap;
+    light: Readonly<Record<string, unknown>> | null;
+}): null;

package/dist/LightBinding.web.js

@@ -0,0 +1,19 @@
+/**
+ * The style's light, bound to the `light` prop.
+ *
+ * A light is a property of the loaded style, and maplibre-gl sets it with an
+ * imperative `setLight` — so this component holds the one binding that keeps
+ * the engine's light equal to the prop. `null` leaves the document's own
+ * light alone. maplibre-gl diffs the light itself and eases the change.
+ */
+import { useLayoutEffect } from 'react';
+import { runEngineCommand } from './shared';
+export function LightBinding({ map, light, }) {
+    // Binding: the engine's light follows `light` (an imperative style setter).
+    useLayoutEffect(() => {
+        if (!light)
+            return;
+        runEngineCommand('setLight', () => map.setLight(light));
+    }, [map, light]);
+    return null;
+}

package/dist/MapAttribution.d.ts

@@ -0,0 +1,27 @@
+import { MAP_CREDIT_CLEARANCE } from './creditRise';
+import type { MapCreditDisclosure, MapCreditLink } from './types';
+/**
+ * How much of the bottom-right the credit occupies above the bottom edge when
+ * it is one line (`creditRise.ts`). Bottom-right chrome a screen floats there
+ * starts above it and rises by the credit's measured extra height
+ * (`creditHeight.ts`), so the two never overlap.
+ */
+export { MAP_CREDIT_CLEARANCE };
+/**
+ * The credit GoWay's tiles oblige: OpenMapTiles' schema and OpenStreetMap's
+ * data. Always shown, before anything an app adds.
+ */
+export declare const MAP_DATA_CREDITS: readonly MapCreditLink[];
+/**
+ * @param extra - credits owed while something the app draws is on screen,
+ *   after the basemap's own.
+ */
+declare function MapAttributionComponent({ extra, disclosure, expanded, onToggle, }: {
+    extra?: readonly MapCreditLink[];
+    /** A line the credit carries while something it names is drawn, `null` otherwise. */
+    disclosure?: MapCreditDisclosure | null;
+    /** Spelled out, or folded into the ⓘ (`compactCredit.ts`). */
+    expanded: boolean;
+    onToggle: () => void;
+}): import("react").JSX.Element;
+export declare const MapAttribution: import("react").MemoExoticComponent<typeof MapAttributionComponent>;