@trackunit/react-map 0.0.4-alpha-9d327375fc1.0

package/src/panel/PanelOrchestrator.d.ts

@@ -0,0 +1,24 @@
+import type { PanelStore } from "./store/panels";
+export type PanelOrchestratorProps = Readonly<{
+    store: PanelStore;
+    /**
+     * Map container element. The anchored panel layer mounts here so panels
+     * escape the map's overflow.
+     */
+    containerEl: HTMLElement | null;
+    /**
+     * Overlay element that hosts anchored panels via portal. When omitted,
+     * anchored panels render inline next to the orchestrator (used in tests).
+     */
+    anchoredPortalEl?: HTMLElement | null;
+}>;
+/**
+ * Subscribes to the panel store and renders each descriptor as an
+ * `<Panel>` positioned next to its anchor element via Floating UI.
+ *
+ * @internal
+ */
+export declare const PanelOrchestrator: {
+    ({ store, containerEl, anchoredPortalEl }: PanelOrchestratorProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};

package/src/panel/preload/preloadInitiators.d.ts

@@ -0,0 +1,44 @@
+import type { GeoJsonPosition } from "../../core/types";
+/**
+ * Fires `onPreload` when the given `entityId` has been hovered continuously
+ * for `debounceMs` milliseconds. Rapid mouse passes are filtered out.
+ *
+ * The consumer owns hover state — source `entityId` from
+ * `layers.interaction.hoveredEntity?.id ?? null`.
+ */
+export type HoverPanelPreloadInitiator = Readonly<{
+    type: "hover";
+    entityId: string | null;
+    /**
+     * Milliseconds to wait before firing `onPreload` after hover starts.
+     * Default: 150.
+     */
+    debounceMs?: number;
+}>;
+/**
+ * Fires `onPreload` for the `count` entities nearest to `referenceEntityId`
+ * whenever the reference changes or the map viewport moves.
+ *
+ * When `referenceEntityId` is `null` the initiator is skipped — pass the
+ * currently-selected entity id to pre-warm data for adjacent assets.
+ */
+export type ProximityPanelPreloadInitiator = Readonly<{
+    type: "proximity";
+    /**
+     * ID of the entity to compute proximity from.
+     * `null` disables the initiator until a selection is made.
+     */
+    referenceEntityId: string | null;
+    /** All visible entities with their positions for proximity ranking. */
+    entities: ReadonlyArray<Readonly<{
+        id: string;
+        position: GeoJsonPosition;
+    }>>;
+    /**
+     * Maximum number of nearest entities to preload.
+     * Default: 5.
+     */
+    count?: number;
+}>;
+export type PanelPreloadInitiator = HoverPanelPreloadInitiator | ProximityPanelPreloadInitiator;
+export type PanelPreloadInitiatorType = PanelPreloadInitiator["type"];

package/src/panel/preload/useHoverPreloadInitiator.d.ts

@@ -0,0 +1,8 @@
+import type { HoverPanelPreloadInitiator, PanelPreloadInitiatorType } from "./preloadInitiators";
+/**
+ * Fires `onShouldPreload` for the currently hovered entity after a debounce
+ * delay. Rapid mouse passes that do not settle cancel any pending timer.
+ *
+ * @internal
+ */
+export declare const useHoverPreloadInitiator: (initiator: HoverPanelPreloadInitiator | undefined, onShouldPreload: (id: string, type: PanelPreloadInitiatorType) => void) => void;

package/src/panel/preload/usePanelPreload.d.ts

@@ -0,0 +1,46 @@
+import type { MapApi } from "../../core/types";
+import type { PanelPreloadInitiator, PanelPreloadInitiatorType } from "./preloadInitiators";
+export type UsePanelPreloadOptions = Readonly<{
+    /**
+     * Called at most once per entity per hook mount when any initiator
+     * determines the entity's data should be prefetched.
+     *
+     * May be called for the same entity from multiple initiators — idempotency
+     * is the consumer's responsibility. Apollo's `fetchPolicy: "cache-first"`
+     * handles this naturally: a second call is a no-op when data is cached.
+     */
+    onPreload: (entityId: string, initiator: PanelPreloadInitiatorType) => void;
+    /**
+     * One or more preload triggers. Each one independently decides which
+     * entities to preload — pass both `hover` and `proximity` to get layered
+     * coverage.
+     */
+    initiators: ReadonlyArray<PanelPreloadInitiator>;
+}>;
+/**
+ * Registers preload initiators for a map panel.
+ *
+ * Fires `onPreload` when an initiator determines an entity's data should be
+ * fetched before the panel opens — so the Apollo cache is warm by the time
+ * the user selects the marker.
+ *
+ * The hook is data-agnostic: the consumer decides what to fetch in `onPreload`.
+ *
+ * ```tsx
+ * const client = useApolloClient();
+ * usePanelPreload(api, {
+ *   onPreload: (entityId) => {
+ *     void client.query({
+ *       query: GetEntityDocument,
+ *       variables: { entityId },
+ *       fetchPolicy: "cache-first",
+ *     });
+ *   },
+ *   initiators: [
+ *     { type: "hover", entityId: layers.interaction.hoveredEntity?.id ?? null },
+ *     { type: "proximity", referenceEntityId: selectedEntityId, entities: markers, count: 3 },
+ *   ],
+ * });
+ * ```
+ */
+export declare const usePanelPreload: (api: MapApi, options: UsePanelPreloadOptions) => void;

package/src/panel/preload/useProximityPreloadInitiator.d.ts

@@ -0,0 +1,13 @@
+import type { MapApi } from "../../core/types";
+import type { PanelPreloadInitiatorType, ProximityPanelPreloadInitiator } from "./preloadInitiators";
+/**
+ * Fires `onShouldPreload` for the `count` entities closest to
+ * `referenceEntityId`. Skips entirely when `referenceEntityId` is `null`.
+ *
+ * Subscribes to `api.on("moveend")` to re-trigger after map pans — entities
+ * prop updates when new markers arrive in the viewport, so the nearest set
+ * may change after each pan.
+ *
+ * @internal
+ */
+export declare const useProximityPreloadInitiator: (initiator: ProximityPanelPreloadInitiator | undefined, api: MapApi, onShouldPreload: (id: string, type: PanelPreloadInitiatorType) => void) => void;

package/src/panel/store/panels.d.ts

@@ -0,0 +1,76 @@
+import type { Placement } from "@floating-ui/react";
+import type { ReactNode } from "react";
+/**
+ * Internal descriptor describing a map panel registered by a layer.
+ *
+ * Layers register panels via {@link usePanel}; the orchestrator renders
+ * each descriptor as an {@link Panel} positioned next to its anchor.
+ *
+ * `children` is the panel content. `onDismiss` is the latest closure the
+ * orchestrator should invoke when the panel is dismissed (Escape key or
+ * outside-press) — the hook ships a stable wrapper that reads from a ref so
+ * handler-identity changes do not cause extra store ticks.
+ *
+ * @internal
+ */
+export type PanelDescriptor = Readonly<{
+    id: string;
+    /**
+     * Anchor element. The orchestrator passes this to Floating UI as the
+     * reference element. Null until the consumer mounts.
+     */
+    anchor: HTMLElement | null;
+    /** Lower number = higher priority. */
+    priority?: number;
+    /** Placement preference. Default: "bottom". */
+    placement?: Placement;
+    onDismiss?: () => void;
+    /** Accessible label for the close button. Passed through to Panel. */
+    closeLabel?: string;
+    /** Accessible label for the panel dialog, announced by screen readers on open. */
+    "aria-label"?: string;
+    /**
+     * Where vertical overflow scrolls. Default `shell` keeps `overflow-auto` on the
+     * Panel scroll slot; `internal` uses `overflow-hidden` so consumers own scroll.
+     */
+    contentScroll?: "shell" | "internal";
+    /**
+     * Called by the orchestrator (via Panel.onCommit) on first visible
+     * placement per open-cycle. Wired by `usePanel` when `resolveAutoPan`
+     * is provided. Fourth arg is the natural content height of the inner scroll div.
+     */
+    onCommit?: (panelRect: DOMRect, anchorRect: DOMRect, placement: Placement, panelScrollHeight: number) => void;
+    children: ReactNode;
+}>;
+/**
+ * Subscription-based store for map panels.
+ *
+ * Compatible with `useSyncExternalStore(subscribe, getSnapshot)`.
+ *
+ * Unlike the annotation store, panels use `upsert` semantics: the consumer
+ * hook calls `upsert` on every render where the panel is open. `upsert`
+ * replaces the descriptor in place without changing insertion order, so
+ * children and other content fields can change without unmounting the
+ * orchestrator's slot for that id.
+ *
+ * @internal
+ */
+export type PanelStore = Readonly<{
+    upsert: (descriptor: PanelDescriptor) => void;
+    remove: (id: string) => void;
+    subscribe: (callback: () => void) => () => void;
+    getSnapshot: () => ReadonlyArray<PanelDescriptor>;
+}>;
+/**
+ * Creates a {@link PanelStore} instance.
+ *
+ * Uses a `Map<string, PanelDescriptor>` for registration so that
+ * insertion order is preserved across `upsert` calls (Map iteration order
+ * is insertion order, and `set` on an existing key does not move it).
+ *
+ * `getSnapshot` returns a stable `ReadonlyArray` reference that only
+ * changes when descriptors are actually mutated.
+ *
+ * @internal
+ */
+export declare const createPanelStore: () => PanelStore;

package/src/panel/storyHelpers.d.ts

@@ -0,0 +1,9 @@
+import type { MapApi } from "../core/types";
+/**
+ * Lightweight `MapApi` mock for Storybook stories that exercise
+ * `usePanel` and `PanelOrchestrator` without spinning up a real map
+ * adapter.
+ *
+ * @internal
+ */
+export declare const createMockMapApiForStories: () => MapApi;

package/src/panel/usePanel.d.ts

@@ -0,0 +1,81 @@
+import type { Placement } from "@floating-ui/react";
+import { type ReactNode, type RefCallback } from "react";
+import type { MapApi } from "../core/types";
+import type { AutoPanContext, AutoPanResult } from "./utils/autoPan";
+export type UsePanelOptions = Readonly<{
+    /** Stable id used as the descriptor key in the panel store. */
+    id: string;
+    /**
+     * When true, the panel is registered (or upserted) on every render.
+     * When false (or after unmount), the panel is removed from the store.
+     * Toggle this instead of conditionally calling the hook.
+     */
+    open: boolean;
+    /** Lower number = higher priority. Default active in the Sheet carousel. */
+    priority?: number;
+    /** Floating-mode placement preference. Default: "bottom". */
+    placement?: Placement;
+    /**
+     * Called on Sheet gesture/ESC dismiss (when this descriptor is the active
+     * one in the carousel) or on floating-mode outside-press. The hook captures
+     * the latest closure on every render, so consumers do not need to memoize.
+     */
+    onDismiss?: () => void;
+    /**
+     * Accessible label for the close button rendered by the panel shell.
+     * Pass `t("panel.close")` from the consuming library to keep it translated.
+     * Defaults to `"Close"` when omitted.
+     */
+    closeLabel?: string;
+    /**
+     * Accessible label for the panel dialog, announced by screen readers on open.
+     * Pass `t("panel.label")` from the consuming library to keep it translated.
+     */
+    "aria-label"?: string;
+    /**
+     * Where vertical overflow scrolls. Default `shell` keeps the Panel scroll slot
+     * as `overflow-auto`; use `internal` when panel content owns its own scroll region.
+     */
+    contentScroll?: "shell" | "internal";
+    /**
+     * Optional resolver for auto-panning the map when the panel first commits
+     * in anchored mode. Called once per open-cycle with an {@link AutoPanContext}
+     * describing the panel's position relative to the map container. Return an
+     * `{ x, y }` pixel offset to pan by, or `null` to skip panning.
+     *
+     * Use {@link defaultAutoPanResolver} for the standard behavior (pan minimum
+     * to clear clipping with 12 px padding):
+     *
+     * ```tsx
+     * import { defaultAutoPanResolver } from "@trackunit/react-map";
+     *
+     * usePanel(api, {
+     *   id: "my-panel",
+     *   open: isOpen,
+     *   resolveAutoPan: defaultAutoPanResolver,
+     *   children: <MyContent />,
+     * });
+     * ```
+     *
+     * Omit to opt out of auto-panning entirely.
+     */
+    resolveAutoPan?: (ctx: AutoPanContext) => AutoPanResult;
+    /**
+     * Panel content. Identity may change every render; the hook upserts the
+     * descriptor in place so the orchestrator simply re-renders the existing
+     * slot for this id without remounting Floating UI or the Sheet.
+     */
+    children: ReactNode;
+}>;
+/**
+ * Registers a panel for the given map and returns a callback ref that the
+ * consumer must spread on the anchor element (typically `<MapMarker ref={...}>`).
+ *
+ * The orchestrator owned by `createMapComponent` decides whether to render
+ * the panel as a Sheet (narrow containers) or a floating element anchored
+ * to the marker (wide containers).
+ *
+ * The returned ref callback identity is stable across re-renders; consumers
+ * can pass it to multiple refs via `useMergeRefs` if needed.
+ */
+export declare const usePanel: (api: MapApi, options: UsePanelOptions) => RefCallback<HTMLElement>;

package/src/panel/utils/autoPan.d.ts

@@ -0,0 +1,78 @@
+import type { Placement } from "@floating-ui/react";
+/**
+ * Context passed to `resolveAutoPan` when an anchored panel first commits.
+ *
+ * `clipping` values are positive when the panel overflows the map container
+ * on that side (e.g. `clipping.right = 20` means the panel extends 20 px
+ * beyond the container's right edge).
+ *
+ * `panelScrollHeight` is the natural content height of the panel's inner scroll
+ * div — equal to `panelRect.height` when content fits, greater when the panel
+ * is scroll-constrained. Combined with `panelCssMaxHeight`, this lets resolvers
+ * compute how much panning would eliminate (or reduce) scrolling.
+ *
+ * `panelCssMaxHeight` is the effective CSS `max-height` cap on the panel shell
+ * (`min(320px, 40vh)` evaluated at commit time). Panning beyond what's needed
+ * to reach this cap does not reduce scrolling further.
+ */
+export type AutoPanContext = Readonly<{
+    panelRect: DOMRect;
+    anchorRect: DOMRect;
+    containerRect: DOMRect;
+    placement: Placement;
+    clipping: Readonly<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }>;
+    /** Natural content height of the inner scroll div (from `scrollHeight`). */
+    panelScrollHeight: number;
+    /** Effective CSS `max-height` on the panel shell at commit time. */
+    panelCssMaxHeight: number;
+}>;
+/**
+ * Return value from `resolveAutoPan`.
+ *
+ * `x` and `y` are screen-space pixel offsets for `api.actions.panBy`:
+ *   - positive x = pan map right (content moves left)
+ *   - positive y = pan map down  (content moves up)
+ *
+ * Return `null` to skip panning (panel already fits).
+ *
+ * When `restoreOnDismiss` is `true` (or omitted), `usePanel` captures the
+ * map center before panning and calls `panTo(capturedCenter)` when the panel
+ * is dismissed — returning the viewport to its pre-pan position.
+ * Set to `false` to opt out of the restore.
+ */
+export type AutoPanResult = Readonly<{
+    x: number;
+    y: number;
+    restoreOnDismiss?: boolean;
+}> | null;
+/**
+ * Default auto-pan resolver: pans the minimum amount to give the panel the
+ * best possible screen space. Handles two cases:
+ *
+ * 1. **Clipping** — panel bleeds outside the map container on any side. Pans
+ *    to clear the bleed with 12 px of breathing room.
+ *
+ * 2. **Scroll-squish** — panel is within the container but shift-pressed against
+ *    an edge, so content overflows and the panel scrolls. Pans to give the panel
+ *    room to grow, up to the CSS `max-height` cap (`panelCssMaxHeight`).
+ *
+ * Returns `null` when the panel already fits without scrolling and without
+ * clipping — meaning no pan is needed.
+ *
+ * Pass as `resolveAutoPan` to {@link usePanel} for the standard behavior:
+ *
+ * ```tsx
+ * usePanel(api, {
+ *   id: "my-panel",
+ *   open: isOpen,
+ *   resolveAutoPan: defaultAutoPanResolver,
+ *   children: <MyPanelContent />,
+ * });
+ * ```
+ */
+export declare const defaultAutoPanResolver: (ctx: AutoPanContext) => AutoPanResult;

package/src/panel/utils/panelShellConstants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CSS `max-height` of the Panel shell — `min(320px, 40vh)`.
+ *
+ * Both values are kept here so the inline style in `Panel` and the
+ * auto-pan cap computation in `usePanel` always stay in sync.
+ */
+export declare const PANEL_MAX_HEIGHT_PX = 320;
+export declare const PANEL_MAX_HEIGHT_VH = 40;

package/src/panel/utils/useAutoPanResolver.d.ts

@@ -0,0 +1,23 @@
+import { defaultAutoPanResolver } from "./autoPan";
+export type AutoPanResolverHelpers = Readonly<{
+    defaultAutoPanResolver: typeof defaultAutoPanResolver;
+}>;
+/**
+ * Build-your-own hook: stable reference to the default auto-pan resolver.
+ *
+ * Returns `defaultAutoPanResolver` for consumers who want to pass it to
+ * `usePanel({ resolveAutoPan })` or use it as a baseline to wrap/replace
+ * with custom logic.
+ *
+ * @example
+ * ```tsx
+ * const { defaultAutoPanResolver } = useAutoPanResolver();
+ * usePanel(api, {
+ *   id: "my-panel",
+ *   open: isOpen,
+ *   resolveAutoPan: defaultAutoPanResolver,
+ *   children: <MyContent />,
+ * });
+ * ```
+ */
+export declare const useAutoPanResolver: () => AutoPanResolverHelpers;

package/src/panel/utils/useWheelForwarding.d.ts

@@ -0,0 +1,18 @@
+import { type RefObject } from "react";
+/**
+ * Lets wheel events reach the map natively when a zoom gesture started on the
+ * map and the cursor later moves over the panel overlay.
+ *
+ * Pass-through uses `data-wheel-pass-through` + CSS `pointer-events: none` so
+ * the browser delivers trusted wheel events to the map underneath. It is armed
+ * only while a map-originated wheel gesture is in progress — panel-initiated
+ * wheels and all pointer interaction keep the panel fully interactive.
+ *
+ * Gesture ownership is decided on the first wheel tick of each burst (after an
+ * idle gap): target inside the panel shell → panel; otherwise → map. A
+ * `pointerdown` on the panel ends any map wheel gesture immediately so clicks
+ * and drags on the panel always win.
+ */
+export declare const useWheelForwarding: (shellRef: RefObject<HTMLElement | null>, 
+/** Re-run effects when the panel shell mounts or unmounts. */
+isActive: boolean) => void;

package/src/stories/InteractionDisplay.d.ts

@@ -0,0 +1,9 @@
+import type { MapInteractionState } from "@trackunit/react-map-adapter-shared";
+import type { ReactElement } from "react";
+type InteractionDisplayProps = {
+    interaction: MapInteractionState;
+    label?: string;
+};
+/** Formatted selected/hovered entity display with outlined entity blocks showing all fields. */
+export declare const InteractionDisplay: ({ interaction, label }: InteractionDisplayProps) => ReactElement;
+export {};

package/src/stories/PositionDisplay.d.ts

@@ -0,0 +1,9 @@
+import type { ReactElement } from "react";
+import type { GeoJsonPosition } from "../core/types";
+type PositionDisplayProps = {
+    position: Readonly<GeoJsonPosition>;
+    label?: string;
+};
+/** Color-coded Lng/Lat coordinate cells, matching StateDisplay's center rendering. */
+export declare const PositionDisplay: ({ position, label }: PositionDisplayProps) => ReactElement;
+export {};

package/src/stories/_storyCoordUtils.d.ts

@@ -0,0 +1,8 @@
+/** Pads numeric string: 3-digit int part + reserved sign column to avoid layout shift when sign flips. */
+export declare const formatPaddedNumber: (n: number, decimals: number) => string;
+export declare const cvaCoordCell: (props?: ({
+    variant?: "lng" | "lat" | "we" | "sn" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const cvaStateDisplay: (props?: ({
+    expanded?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/src/testing/mockMapApi.d.ts

@@ -0,0 +1,29 @@
+import type { MapApi, MapState } from "../core/types";
+/**
+ * Builds a full `MapApi` stub for use in unit tests and hook-stability specs.
+ *
+ * Uses the real `createPanelStore`, `createMapAnnotationStore`, and
+ * `createMapLoadingIndicatorStore` so store state can be asserted on
+ * (e.g. a test can register an annotation and then assert `getSnapshot()`).
+ *
+ * Action stubs (setCenter, fitBounds, panTo, etc.) are plain no-ops that
+ * return a resolved `Promise<void>`. Pass `actionOverrides` to replace any
+ * action with a spy or custom implementation.
+ *
+ * @example
+ * ```ts
+ * // Basic usage — real stores, no-op actions:
+ * const api = mockMapApi();
+ *
+ * // Override specific actions for assertion:
+ * const fitBounds = vi.fn().mockResolvedValue(undefined);
+ * const api = mockMapApi({ actions: { fitBounds } });
+ *
+ * // Override state (e.g. a ready map at zoom 15):
+ * const api = mockMapApi({ state: { zoom: 15 } });
+ * ```
+ */
+export declare const mockMapApi: (overrides?: {
+    state?: Partial<MapState>;
+    actions?: Partial<MapApi["actions"]>;
+}) => MapApi;

package/src/translation.d.ts

@@ -0,0 +1,30 @@
+import { NamespaceTransProps, TransForLibs, TranslationResource, useNamespaceTranslation } from "@trackunit/i18n-library-translation";
+import { ReactElement } from "react";
+import defaultTranslations from "./locales/en/translation.json";
+/** A type for all available translation keys in this library */
+export type TranslationKeys = keyof typeof defaultTranslations;
+/** The translation namespace for this library */
+export declare const namespace = "react-map.map";
+/**
+ * The TranslationResource for this Library.
+ * Holds lazy loaded imports for all languages supported by the library.
+ *
+ * This is used to register the translations for this library before initializing i18next.
+ */
+export declare const translations: TranslationResource<TranslationKeys>;
+/**
+ *  Local useTranslation for this specific library
+ */
+export declare const useTranslation: () => ReturnType<typeof useNamespaceTranslation<TranslationKeys>>;
+/**
+ * Type of the t function for the local useTranslation for this specific library
+ */
+export type TranslationFunction = TransForLibs<TranslationKeys>;
+/**
+ * Trans for this specific library.
+ */
+export declare const Trans: (props: NamespaceTransProps<TranslationKeys>) => ReactElement;
+/**
+ * Registers the translations for this library
+ */
+export declare const setupLibraryTranslations: () => void;

package/translation.cjs.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var translation = {
+	"controls.allControls": "Kartensteuerung",
+	"controls.boolean.tooltip": "{{label}} aktivieren/deaktivieren",
+	"controls.category.navigation": "Navigation",
+	"controls.category.settings": "Einstellungen",
+	"controls.category.statistics": "Statistiken",
+	"controls.category.tools": "Werkzeuge",
+	"controls.enterFullscreen": "Vollbildmodus aktivieren",
+	"controls.exitFullscreen": "Vollbildmodus beenden",
+	"controls.myLocation": "Meinen Standort anzeigen",
+	"controls.stepper.decrease": "Verkleinern",
+	"controls.stepper.increase": "Vergrößern",
+	"controls.zoom": "Zoom",
+	"controls.zoomIn": "Hineinzoomen",
+	"controls.zoomOut": "Herauszoomen",
+	"map.loading": "Karte wird geladen",
+	"map.loadingData": "Loading map data",
+	"map.loadingErrorMessage": "Die Karte konnte nicht geladen werden. Bitte versuchen Sie es später erneut.",
+	"multiGeometry.badge.tooltip": "Teil eines zusammengesetzten Objekts",
+	"settings.mapStyle.dark": "Dunkel",
+	"settings.mapStyle.light": "Hell",
+	"settings.mapStyle.roadmap": "Straßenkarte",
+	"settings.mapStyle.roads": "Straßen",
+	"settings.mapStyle.satellite": "Satellit",
+	"settings.mapStyle.title": "Kartenstil"
+};
+
+exports.default = translation;

package/translation.cjs10.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var translation = {
+	"controls.allControls": "Sterowanie mapą",
+	"controls.boolean.tooltip": "Przełącz: {{label}}",
+	"controls.category.navigation": "Nawigacja",
+	"controls.category.settings": "Ustawienia",
+	"controls.category.statistics": "Statystyki",
+	"controls.category.tools": "Narzędzia",
+	"controls.enterFullscreen": "Przejdź do trybu pełnoekranowego",
+	"controls.exitFullscreen": "Zamknij pełny ekran",
+	"controls.myLocation": "Pokaż moją lokalizację",
+	"controls.stepper.decrease": "Zmniejsz",
+	"controls.stepper.increase": "Zwiększ",
+	"controls.zoom": "Powiększ",
+	"controls.zoomIn": "Przybliż",
+	"controls.zoomOut": "Oddal",
+	"map.loading": "Ładowanie mapy",
+	"map.loadingData": "Loading map data",
+	"map.loadingErrorMessage": "Nie można załadować mapy. Spróbuj ponownie później.",
+	"multiGeometry.badge.tooltip": "Część kształtu wieloczęściowego",
+	"settings.mapStyle.dark": "Ciemny",
+	"settings.mapStyle.light": "Jasny",
+	"settings.mapStyle.roadmap": "Mapa drogowa",
+	"settings.mapStyle.roads": "Drogi",
+	"settings.mapStyle.satellite": "Satelita",
+	"settings.mapStyle.title": "Styl mapy"
+};
+
+exports.default = translation;

package/translation.cjs11.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var translation = {
+	"controls.allControls": "Controlos do mapa",
+	"controls.boolean.tooltip": "Alternar: {{label}}",
+	"controls.category.navigation": "Navegação",
+	"controls.category.settings": "Definições",
+	"controls.category.statistics": "Estatísticas",
+	"controls.category.tools": "Ferramentas",
+	"controls.enterFullscreen": "Entrar em ecrã completo",
+	"controls.exitFullscreen": "Sair do ecrã completo",
+	"controls.myLocation": "Mostrar a minha localização",
+	"controls.stepper.decrease": "Diminuir",
+	"controls.stepper.increase": "Aumentar",
+	"controls.zoom": "Ampliar",
+	"controls.zoomIn": "Aumentar zoom",
+	"controls.zoomOut": "Diminuir zoom",
+	"map.loading": "Carregar mapa",
+	"map.loadingData": "Loading map data",
+	"map.loadingErrorMessage": "Não foi possível carregar o mapa. Tente novamente mais tarde.",
+	"multiGeometry.badge.tooltip": "Parte de uma forma de várias partes",
+	"settings.mapStyle.dark": "Escuro",
+	"settings.mapStyle.light": "Claro",
+	"settings.mapStyle.roadmap": "Mapa de estrada",
+	"settings.mapStyle.roads": "Estradas",
+	"settings.mapStyle.satellite": "Satélite",
+	"settings.mapStyle.title": "Estilo do mapa"
+};
+
+exports.default = translation;

package/translation.cjs12.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var translation = {
+	"controls.allControls": "Элементы управления картой",
+	"controls.boolean.tooltip": "Переключатель: {{label}}",
+	"controls.category.navigation": "Навигация",
+	"controls.category.settings": "Настройки",
+	"controls.category.statistics": "Статистика",
+	"controls.category.tools": "Инструменты",
+	"controls.enterFullscreen": "Войти в полноэкранный режим",
+	"controls.exitFullscreen": "Выйти из полноэкранного режима",
+	"controls.myLocation": "Показать мое местоположение",
+	"controls.stepper.decrease": "Уменьшить",
+	"controls.stepper.increase": "Увеличить",
+	"controls.zoom": "Масштаб",
+	"controls.zoomIn": "Увеличить масштаб",
+	"controls.zoomOut": "Уменьшить масштаб",
+	"map.loading": "Загрузка карты",
+	"map.loadingData": "Loading map data",
+	"map.loadingErrorMessage": "Не удается загрузить карту. Повторите попытку позже.",
+	"multiGeometry.badge.tooltip": "Часть составной фигуры",
+	"settings.mapStyle.dark": "Темная",
+	"settings.mapStyle.light": "Светлая",
+	"settings.mapStyle.roadmap": "Карта маршрута",
+	"settings.mapStyle.roads": "Дороги",
+	"settings.mapStyle.satellite": "Спутник",
+	"settings.mapStyle.title": "Стиль карты"
+};
+
+exports.default = translation;