@kepler.gl/deckgl-layers 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/globe/atmosphere-layer.d.ts

@@ -0,0 +1,58 @@
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import { type GlobeConfig } from '@kepler.gl/constants';
+/**
+ * Convert a mapState zoom level to a [0, 1] atmosphere opacity multiplier.
+ * Returns 1 (fully visible) below ATMOSPHERE_FADE_ZOOM_START, smoothly
+ * interpolates to 0 between the two thresholds, and returns 0 above
+ * ATMOSPHERE_FADE_ZOOM_END.
+ */
+export declare function atmosphereZoomFade(zoom: number): number;
+type AtmosphereLayerProps = {
+    config: GlobeConfig;
+    /** Pre-computed [0, 1] zoom-fade multiplier; 1 = fully visible, 0 = hidden. */
+    zoomFade: number;
+};
+export declare class AtmosphereLayerRealistic extends SimpleMeshLayer<any, AtmosphereLayerProps> {
+    static layerName: string;
+    draw({ uniforms }: {
+        uniforms: object;
+    }): void;
+    getShaders(): any;
+}
+export declare class AtmosphereSkyLayerRealistic extends SimpleMeshLayer<any, AtmosphereLayerProps> {
+    static layerName: string;
+    draw({ uniforms }: {
+        uniforms: object;
+    }): void;
+    getShaders(): any;
+}
+/**
+ * View-independent atmosphere: a large uniform emissive aura around the globe.
+ * Unlike AtmosphereSkyLayerRealistic, this ignores sun direction and uses a
+ * linear radial falloff through a thick shell (max at the surface → 0 at outer radius).
+ */
+export declare class AtmosphereHugeHaloLayer extends SimpleMeshLayer<any, AtmosphereLayerProps> {
+    static layerName: string;
+    draw({ uniforms }: {
+        uniforms: object;
+    }): void;
+    getShaders(): any;
+}
+export declare const getGlobeAtmosphereLayer: ({ config, zoom }: {
+    config: GlobeConfig;
+    zoom?: number;
+}) => AtmosphereLayerRealistic;
+/** Realistic sun-lit scattering sky halo (thin limb glow). */
+export declare const getGlobeAtmosphereSkyLayer: ({ config, zoom }: {
+    config: GlobeConfig;
+    zoom?: number;
+}) => AtmosphereSkyLayerRealistic;
+/**
+ * Large uniform glow drawn in addition to the realistic sky halo when
+ * `config.hugeHalo` is enabled. Returns null when disabled.
+ */
+export declare const getGlobeHugeHaloLayer: ({ config, zoom }: {
+    config: GlobeConfig;
+    zoom?: number;
+}) => AtmosphereHugeHaloLayer | null;
+export {};

package/dist/globe/enhanced-multi-icon-layer.d.ts

@@ -0,0 +1,6 @@
+declare const EnhancedMultiIconLayer_base: any;
+export default class EnhancedMultiIconLayer extends EnhancedMultiIconLayer_base {
+    static layerName: string;
+    getShaders(): any;
+}
+export {};

package/dist/globe/globe-depth-disk-layer.d.ts

@@ -0,0 +1,19 @@
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import type { RGBColor } from '@kepler.gl/types';
+export declare const GLOBE_COMMON_RADIUS = 256;
+/**
+ * Creates a view-oriented disk positioned along the direction from the globe's center to the camera.
+ * The disk is a cross-section of the globe between the front (visible) and back side, and it fills
+ * the depth buffer so anything on the far side of the globe (e.g. arcs/lines) is depth-culled and
+ * hidden behind the planet.
+ */
+export declare class GlobeDepthDiskLayer extends SimpleMeshLayer<any> {
+    static layerName: string;
+    getShaders(): any;
+    draw({ uniforms }: {
+        uniforms: object;
+    }): void;
+}
+export declare const getGlobeDepthDiskLayer: ({ fillColor }: {
+    fillColor?: RGBColor;
+}) => GlobeDepthDiskLayer;

package/dist/globe/globe-layers.d.ts

@@ -0,0 +1,108 @@
+import { Layer } from '@deck.gl/core';
+import type { Globe } from '@kepler.gl/constants';
+import type { RGBColor } from '@kepler.gl/types';
+type LayerGroup = {
+    slug: string;
+    filter: (layer: any) => boolean;
+};
+export declare const DEFAULT_BASEMAP_COLOR: {
+    backgroundFillColor: RGBColor;
+    basemapDefaultFillColor: RGBColor;
+    basemapWaterFillColor: RGBColor;
+    basemapDefaultLineColor: RGBColor;
+    basemapAdminLineColor: RGBColor;
+    basemapLabelColor: RGBColor;
+};
+export declare const getBasemapColors: (mapStyle: Partial<{
+    style: any;
+    layerGroups: LayerGroup[];
+}>) => {
+    backgroundFillColor: RGBColor;
+    basemapWaterFillColor: RGBColor;
+    basemapAdminLineColor: RGBColor;
+    basemapLabelColor: RGBColor;
+};
+/**
+ * Get basemap colors either from the style JSON or from known style presets.
+ * Falls back to default dark colors if style is unknown and no JSON is available.
+ */
+export declare const getBasemapColorsForStyle: (styleType: string, mapStyle?: Partial<{
+    style: any;
+    layerGroups: LayerGroup[];
+}>) => {
+    backgroundFillColor: RGBColor;
+    basemapWaterFillColor: RGBColor;
+    basemapAdminLineColor: RGBColor;
+    basemapLabelColor: RGBColor;
+};
+/**
+ * Clear color (background around the globe) for globe mode, in RGBA 0-255 as
+ * expected by deck.gl's View `clearColor` prop (deck.gl >= 9 no longer supports
+ * the global `parameters.clearColor`; it must be set per-view with `clear: true`).
+ */
+export declare function getGlobeClearColor(backgroundColor?: [number, number, number] | number[]): [number, number, number, number];
+/**
+ * Globe basemap tile provider.
+ *
+ * - `mapbox` uses Mapbox vector/raster tiles and requires an access token.
+ * - `carto` uses CARTO's free OpenMapTiles vector tiles + Esri World Imagery
+ *   raster, and needs no token. Used as an automatic fallback when no Mapbox
+ *   token is available (e.g. MapLibre / CARTO basemap setups), so the globe
+ *   basemap still renders instead of showing a solid-color sphere.
+ */
+export type GlobeBasemapProvider = 'mapbox' | 'carto';
+/**
+ * Resolve which globe basemap tile provider to use.
+ *
+ * The globe should follow the *selected basemap style's* rendering library so
+ * it stays consistent with the flat 2D map: a MapLibre/CARTO style uses the
+ * free CARTO tiles (even when a Mapbox token is available), and a Mapbox style
+ * uses Mapbox tiles. A Mapbox style with no token falls back to CARTO so the
+ * globe still renders instead of showing a bare colored sphere.
+ *
+ * @param baseMapLibrary the selected style's library ('mapbox' | 'maplibre'),
+ *   e.g. from `getBaseMapLibrary(currentStyle)`.
+ */
+export declare const resolveGlobeBasemapProvider: (baseMapLibrary: "mapbox" | "maplibre" | undefined, mapboxApiAccessToken?: string) => GlobeBasemapProvider;
+export type GlobeAttribution = {
+    label: string;
+    href: string;
+};
+/**
+ * Resolve the tile-source attribution entries for the globe basemap. deck.gl
+ * renders the globe basemap tiles itself (not the base Maplibre/Mapbox map), so
+ * the base map's attribution machinery never sees them. This lets the UI credit
+ * the actual tile provider(s) in globe mode.
+ */
+export declare const getGlobeBasemapAttributions: ({ globe, mapboxApiAccessToken, mapStyleType, basemapProvider }: {
+    globe?: Globe;
+    mapboxApiAccessToken?: string;
+    mapStyleType?: string;
+    basemapProvider?: GlobeBasemapProvider;
+}) => GlobeAttribution[];
+export declare const getGlobeBaseLayers: ({ mapboxApiAccessToken, globe, mapStyleType, basemapProvider, latitude, zoom }: {
+    mapboxApiAccessToken: string;
+    globe: Globe;
+    mapStyleType?: string;
+    /**
+     * Which tile provider to use for the globe basemap. Defaults to `mapbox` when
+     * a token is present, otherwise falls back to the token-free `carto` tiles.
+     */
+    basemapProvider?: GlobeBasemapProvider;
+    /**
+     * Current camera center latitude. Used to keep tile LOD constant while rotating
+     * toward the poles (deck.gl 9 lowers the effective zoom near the poles). When
+     * omitted, no latitude compensation is applied (equator behavior).
+     */
+    latitude?: number;
+    /**
+     * Current map zoom level. Used to fade the atmosphere effects out when the user
+     * zooms in past a certain threshold (mirrors Google Maps globe behaviour).
+     */
+    zoom?: number;
+}) => Layer[];
+export declare const getGlobeTopLayers: ({ globe, zoom }: {
+    globe: Globe;
+    zoom?: number;
+}) => Layer[];
+export {};

package/dist/globe/globe-stars-layer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns a data URL of a tileable star-field image (512×512 PNG).
+ * Generates the image once and caches it for subsequent calls.
+ */
+export declare function getStarsBackgroundImage(): string;
+/**
+ * Tile the star-field onto a 2D canvas (e.g. video-export frame capture).
+ * Stars are drawn with alpha so the caller should fill the background color first.
+ */
+export declare function drawStarsBackground(ctx: CanvasRenderingContext2D, width: number, height: number): void;

package/dist/globe/globe-stars-layer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/globe/globe-view.d.ts

@@ -0,0 +1,23 @@
+declare const DeckGlobeView: any;
+declare const GlobeController: any;
+/**
+ * Custom GlobeController that restores zoom-to-cursor behavior.
+ *
+ * In deck.gl 9.x, the default GlobeController's GlobeState.zoom() ignores the
+ * cursor position and always zooms toward the center. This controller patches
+ * that behavior by overriding the ControllerState's zoom method to pan the
+ * globe under the cursor while zooming, so zoom-to-cursor works the same way it
+ * does for the 2D MapController.
+ */
+declare class ZoomToCursorGlobeController extends GlobeController {
+    constructor(...args: any[]);
+}
+/**
+ * Custom GlobeView that uses zoom-to-cursor controller behavior.
+ */
+export declare class KeplerGlobeView extends DeckGlobeView {
+    constructor(props?: any);
+    get ControllerType(): typeof ZoomToCursorGlobeController;
+    getViewportType(): any;
+}
+export {};

package/dist/globe/index.d.ts

@@ -0,0 +1,8 @@
+export { AtmosphereLayerRealistic, AtmosphereSkyLayerRealistic, AtmosphereHugeHaloLayer, getGlobeAtmosphereLayer, getGlobeAtmosphereSkyLayer, getGlobeHugeHaloLayer } from './atmosphere-layer';
+export { GlobeDepthDiskLayer, getGlobeDepthDiskLayer } from './globe-depth-disk-layer';
+export { getGlobeBaseLayers, getGlobeTopLayers, getGlobeClearColor, getGlobeBasemapAttributions, resolveGlobeBasemapProvider, DEFAULT_BASEMAP_COLOR, getBasemapColors, getBasemapColorsForStyle } from './globe-layers';
+export type { GlobeBasemapProvider, GlobeAttribution } from './globe-layers';
+export { MVTLabelLayer } from './mvt-label-layer';
+export { default as EnhancedMultiIconLayer } from './enhanced-multi-icon-layer';
+export { KeplerGlobeView } from './globe-view';
+export { getStarsBackgroundImage, drawStarsBackground } from './globe-stars-layer';