@longline/aqua-ui 1.0.303 → 1.0.307

package/map/Map/Map.d.ts

@@ -127,9 +127,10 @@ interface IMapProps {
      */
     onMouseLeave?: (e: MapMouseEvent) => void;
 }
+declare const ViewStateContext: React.Context<ViewState>;
 declare const useViewState: () => ViewState;
 declare const Map: {
     ({ longitude, latitude, zoom, pitch, bearing, logoPosition, interactiveLayerIds, noRotate, preserveDrawingBuffer, minZoom, maxZoom, fadeDuration, doubleClickZoom, ...props }: IMapProps): React.JSX.Element;
     displayName: string;
 };
-export { Map, IMapProps, useViewState };
+export { Map, IMapProps, useViewState, ViewStateContext };

package/map/Map/Map.js

@@ -233,5 +233,5 @@ var Map = function (_a) {
     return React.createElement(MapBase, __assign({ longitude: longitude, latitude: latitude, zoom: zoom, pitch: pitch, bearing: bearing, logoPosition: logoPosition, interactiveLayerIds: interactiveLayerIds, noRotate: noRotate, preserveDrawingBuffer: preserveDrawingBuffer, minZoom: minZoom, maxZoom: maxZoom, fadeDuration: fadeDuration, doubleClickZoom: doubleClickZoom }, props));
 };
 Map.displayName = 'Map';
-export { Map, useViewState };
+export { Map, useViewState, ViewStateContext };
 var templateObject_1;

package/map/layers/InterpolationLayer/ContoursFragmentShader.d.ts

@@ -1,2 +1,2 @@
-declare const ContoursFragmentShader = " \n  #ifdef GL_ES\n  precision mediump float;\n  #endif\n\n  // Screen resolution is needed to convert gl_FragCoord to texture coordinate.\n  uniform vec2 u_resolution;\n  uniform sampler2D dataTexture;\n  uniform int levels;\n  uniform vec4 u_contourColor;\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];\n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  } \n\n  //\n  // Returns texture color at pixelCoord.\n  //\n  vec4 texelFetch(sampler2D tex, vec2 pixelCoord) {\n    return texture2D(tex, pixelCoord / u_resolution);\n  }\n\n  //\n  // Returns texture pixel shade, in a number of levels:\n  int getShade(sampler2D tex, vec2 pixelCoord, float levels) {\n    vec4 color = texelFetch(tex, pixelCoord);\n    // If the color is transparent, return -1, so that there's always a contour line.\n    if(color.w == 0.0) return -1;\n    // Return greyscale shade in levels:\n    return int(color.x * levels);\n  }\n\n  bool hasDifferentShade() {\n    float dist = float(levels);\n\n    // Get shades of input color and surrounding pixels:\n    int shade = getShade(dataTexture, gl_FragCoord.xy, dist);\n    int up    = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y - 1.0), dist);\n    int down  = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y + 1.0), dist);\n    int left  = getShade(dataTexture, vec2(gl_FragCoord.x - 1.0, gl_FragCoord.y), dist);\n    int right = getShade(dataTexture, vec2(gl_FragCoord.x + 1.0, gl_FragCoord.y), dist);\n    return (up != shade || down != shade || left != shade || right != shade);\n  }\n\n  void main() {\n    // Get input color:\n    vec4 color = texelFetch(dataTexture, gl_FragCoord.xy);\n\n    // If input is transparent, draw nothing.\n    if(color.w == 0.0) return;\n\n    // If the shade of the current pixel is different from any of its surrounding\n    // pixels by at least a shade, then draw contour line color.\n    if(levels != 0 && hasDifferentShade()) {\n      gl_FragColor = u_contourColor;\n    } \n    // Otherwise draw the input color.\n    else {\n      gl_FragColor = getGradientColor(color.x);\n    }\n  }\n";
+declare const ContoursFragmentShader = " \n  #ifdef GL_ES\n  precision mediump float;\n  #endif\n\n  // Screen resolution is needed to convert gl_FragCoord to texture coordinate.\n  uniform vec2 u_resolution;\n  uniform sampler2D dataTexture;\n  uniform int levels;\n  uniform vec4 u_contourColor;\n  uniform float u_contourThickness;\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];\n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  } \n\n  //\n  // Returns texture color at pixelCoord.\n  //\n  vec4 texelFetch(sampler2D tex, vec2 pixelCoord) {\n    return texture2D(tex, pixelCoord / u_resolution);\n  }\n\n  //\n  // Returns texture pixel shade, in a number of levels:\n  int getShade(sampler2D tex, vec2 pixelCoord, float levels) {\n    vec4 color = texelFetch(tex, pixelCoord);\n    // If the color is transparent, return -1, so that there's always a contour line.\n    if(color.w == 0.0) return -1;\n    // Return greyscale shade in levels:\n    return int(color.x * levels);\n  }\n\n  bool hasDifferentShade() {\n    float numLevels = float(levels);\n    float offset = max(1.0, u_contourThickness);\n\n    // Get shades of input color and surrounding pixels:\n    int shade = getShade(dataTexture, gl_FragCoord.xy, numLevels);\n    int up    = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y - offset), numLevels);\n    int down  = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y + offset), numLevels);\n    int left  = getShade(dataTexture, vec2(gl_FragCoord.x - offset, gl_FragCoord.y), numLevels);\n    int right = getShade(dataTexture, vec2(gl_FragCoord.x + offset, gl_FragCoord.y), numLevels);\n    return (up != shade || down != shade || left != shade || right != shade);\n  }\n\n  void main() {\n    // Get input color:\n    vec4 color = texelFetch(dataTexture, gl_FragCoord.xy);\n\n    // If input is transparent, draw nothing.\n    if(color.w == 0.0) return;\n\n    // If the shade of the current pixel is different from any of its surrounding\n    // pixels by at least a shade, then draw contour line color.\n    if(levels != 0 && hasDifferentShade()) {\n      gl_FragColor = u_contourColor;\n    } \n    // Otherwise draw the input color.\n    else {\n      gl_FragColor = getGradientColor(color.x);\n    }\n  }\n";
 export { ContoursFragmentShader };

package/map/layers/InterpolationLayer/ContoursFragmentShader.js

@@ -1,2 +1,2 @@
-var ContoursFragmentShader = /*glsl*/ " \n  #ifdef GL_ES\n  precision mediump float;\n  #endif\n\n  // Screen resolution is needed to convert gl_FragCoord to texture coordinate.\n  uniform vec2 u_resolution;\n  uniform sampler2D dataTexture;\n  uniform int levels;\n  uniform vec4 u_contourColor;\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];\n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  } \n\n  //\n  // Returns texture color at pixelCoord.\n  //\n  vec4 texelFetch(sampler2D tex, vec2 pixelCoord) {\n    return texture2D(tex, pixelCoord / u_resolution);\n  }\n\n  //\n  // Returns texture pixel shade, in a number of levels:\n  int getShade(sampler2D tex, vec2 pixelCoord, float levels) {\n    vec4 color = texelFetch(tex, pixelCoord);\n    // If the color is transparent, return -1, so that there's always a contour line.\n    if(color.w == 0.0) return -1;\n    // Return greyscale shade in levels:\n    return int(color.x * levels);\n  }\n\n  bool hasDifferentShade() {\n    float dist = float(levels);\n\n    // Get shades of input color and surrounding pixels:\n    int shade = getShade(dataTexture, gl_FragCoord.xy, dist);\n    int up    = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y - 1.0), dist);\n    int down  = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y + 1.0), dist);\n    int left  = getShade(dataTexture, vec2(gl_FragCoord.x - 1.0, gl_FragCoord.y), dist);\n    int right = getShade(dataTexture, vec2(gl_FragCoord.x + 1.0, gl_FragCoord.y), dist);\n    return (up != shade || down != shade || left != shade || right != shade);\n  }\n\n  void main() {\n    // Get input color:\n    vec4 color = texelFetch(dataTexture, gl_FragCoord.xy);\n\n    // If input is transparent, draw nothing.\n    if(color.w == 0.0) return;\n\n    // If the shade of the current pixel is different from any of its surrounding\n    // pixels by at least a shade, then draw contour line color.\n    if(levels != 0 && hasDifferentShade()) {\n      gl_FragColor = u_contourColor;\n    } \n    // Otherwise draw the input color.\n    else {\n      gl_FragColor = getGradientColor(color.x);\n    }\n  }\n";
+var ContoursFragmentShader = /*glsl*/ " \n  #ifdef GL_ES\n  precision mediump float;\n  #endif\n\n  // Screen resolution is needed to convert gl_FragCoord to texture coordinate.\n  uniform vec2 u_resolution;\n  uniform sampler2D dataTexture;\n  uniform int levels;\n  uniform vec4 u_contourColor;\n  uniform float u_contourThickness;\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];\n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  } \n\n  //\n  // Returns texture color at pixelCoord.\n  //\n  vec4 texelFetch(sampler2D tex, vec2 pixelCoord) {\n    return texture2D(tex, pixelCoord / u_resolution);\n  }\n\n  //\n  // Returns texture pixel shade, in a number of levels:\n  int getShade(sampler2D tex, vec2 pixelCoord, float levels) {\n    vec4 color = texelFetch(tex, pixelCoord);\n    // If the color is transparent, return -1, so that there's always a contour line.\n    if(color.w == 0.0) return -1;\n    // Return greyscale shade in levels:\n    return int(color.x * levels);\n  }\n\n  bool hasDifferentShade() {\n    float numLevels = float(levels);\n    float offset = max(1.0, u_contourThickness);\n\n    // Get shades of input color and surrounding pixels:\n    int shade = getShade(dataTexture, gl_FragCoord.xy, numLevels);\n    int up    = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y - offset), numLevels);\n    int down  = getShade(dataTexture, vec2(gl_FragCoord.x, gl_FragCoord.y + offset), numLevels);\n    int left  = getShade(dataTexture, vec2(gl_FragCoord.x - offset, gl_FragCoord.y), numLevels);\n    int right = getShade(dataTexture, vec2(gl_FragCoord.x + offset, gl_FragCoord.y), numLevels);\n    return (up != shade || down != shade || left != shade || right != shade);\n  }\n\n  void main() {\n    // Get input color:\n    vec4 color = texelFetch(dataTexture, gl_FragCoord.xy);\n\n    // If input is transparent, draw nothing.\n    if(color.w == 0.0) return;\n\n    // If the shade of the current pixel is different from any of its surrounding\n    // pixels by at least a shade, then draw contour line color.\n    if(levels != 0 && hasDifferentShade()) {\n      gl_FragColor = u_contourColor;\n    } \n    // Otherwise draw the input color.\n    else {\n      gl_FragColor = getGradientColor(color.x);\n    }\n  }\n";
 export { ContoursFragmentShader };

package/map/layers/InterpolationLayer/InterpolationLayer.d.ts

@@ -25,6 +25,11 @@ interface IInterpolationLayerProps {
      * @default #35ABE2
      */
     contourColor?: string;
+    /**
+     * Thickness of contour lines in pixels.
+     * @default 1
+     */
+    contourThickness?: number;
     /**
      * Minimum zoom level at which to render layer.
      * @default 0
@@ -42,12 +47,56 @@ interface IInterpolationLayerProps {
     dots?: boolean;
 }
 /**
- * An `InterpolationLayer` takes a data array of the form `{ latitude, longitude, value }`. It performs triangulation
- * and draws the data in an OpenGL layer. Optionally, a number of contour `levels` can be set to draw contour lines.
- * Gradient colors are configurable using `gradientStops`.
+ * A custom WebGL map layer that renders interpolated data with optional contour lines.
+ *
+ * Takes an array of geographic points with values and creates a smooth, gradient-filled
+ * triangulated surface using Delaunay triangulation via Turf.js.
+ *
+ * ## Usage
+ *
+ * ```tsx
+ * <Map>
+ *   <InterpolationLayer
+ *     data={[
+ *       { latitude: 40.7, longitude: -74.0, value: 25 },
+ *       { latitude: 40.8, longitude: -73.9, value: 30 },
+ *       // ...more points
+ *     ]}
+ *     gradientStops={[
+ *       { pos: 0.0, color: '#0000ff' },
+ *       { pos: 0.5, color: '#00ff00' },
+ *       { pos: 1.0, color: '#ff0000' }
+ *     ]}
+ *     levels={16}
+ *     contourColor="#ffffff"
+ *   />
+ * </Map>
+ * ```
+ *
+ * ## Rendering Pipeline
+ *
+ * Uses a two-pass WebGL rendering approach:
+ *
+ * 1. **Pass 1 (off-screen):** Renders triangulated data to a 1024×1024 texture
+ *    as grayscale values (normalized 0-1)
+ * 2. **Pass 2 (on-screen):** Reads the texture, applies gradient colors, and
+ *    optionally draws contour lines by detecting edges between shade levels
+ *
+ * ## Contour Detection
+ *
+ * Contour lines are drawn where adjacent pixels have different "shade levels".
+ * The `levels` prop controls quantization—higher values produce more contour lines.
+ * Set `levels={0}` to disable contour lines entirely.
+ *
+ * ## Data Requirements
+ *
+ * - Minimum 3 points required for triangulation
+ * - Points with `NaN` values are filtered out
+ * - Values are automatically normalized to 0-1 range
  */
 declare const InterpolationLayer: {
-    ({ levels, contourColor, gradientStops, minZoom, maxZoom, dots, ...props }: IInterpolationLayerProps): React.JSX.Element;
+    ({ levels, contourColor, contourThickness, gradientStops, minZoom, maxZoom, dots, ...props }: IInterpolationLayerProps): React.JSX.Element;
     displayName: string;
 };
-export { InterpolationLayer, IInterpolationLayerProps };
+export { InterpolationLayer };
+export type { IInterpolationLayerProps };

package/map/layers/InterpolationLayer/InterpolationLayer.js

@@ -58,7 +58,7 @@ var InterpolationLayerBase = function (props) {
     // Do this by varying its `key` with the current time.
     React.useEffect(function () {
         setTime(Date.now());
-    }, [props.levels, props.data, props.contourColor, props.gradientStops]);
+    }, [props.levels, props.data, props.contourColor, props.contourThickness, props.gradientStops]);
     //
     // Convert IPoint array to polygons.
     //
@@ -257,6 +257,8 @@ var InterpolationLayerBase = function (props) {
         gl.uniformMatrix4fv(gl.getUniformLocation(contoursProgram.current, 'u_matrix'), false, matrix);
         // Pass in levels for contours:
         gl.uniform1i(gl.getUniformLocation(contoursProgram.current, 'levels'), props.levels);
+        // Pass in contour thickness:
+        gl.uniform1f(gl.getUniformLocation(contoursProgram.current, 'u_contourThickness'), props.contourThickness);
         // Pass in contours color:
         var clr = colorToRGBA(props.contourColor);
         gl.uniform4f(gl.getUniformLocation(contoursProgram.current, 'u_contourColor'), clr[0], clr[1], clr[2], clr[3]);
@@ -320,16 +322,59 @@ var InterpolationLayerBase = function (props) {
     return (React.createElement(Layer, { id: null, type: "custom", beforeId: "overlay", key: time, onAdd: onAddLayer, render: function (gl, matrix) { return onRender(gl, matrix, map.current.getZoom(), map.current.getContainer().clientWidth, map.current.getContainer().clientHeight); } }));
 };
 /**
- * An `InterpolationLayer` takes a data array of the form `{ latitude, longitude, value }`. It performs triangulation
- * and draws the data in an OpenGL layer. Optionally, a number of contour `levels` can be set to draw contour lines.
- * Gradient colors are configurable using `gradientStops`.
+ * A custom WebGL map layer that renders interpolated data with optional contour lines.
+ *
+ * Takes an array of geographic points with values and creates a smooth, gradient-filled
+ * triangulated surface using Delaunay triangulation via Turf.js.
+ *
+ * ## Usage
+ *
+ * ```tsx
+ * <Map>
+ *   <InterpolationLayer
+ *     data={[
+ *       { latitude: 40.7, longitude: -74.0, value: 25 },
+ *       { latitude: 40.8, longitude: -73.9, value: 30 },
+ *       // ...more points
+ *     ]}
+ *     gradientStops={[
+ *       { pos: 0.0, color: '#0000ff' },
+ *       { pos: 0.5, color: '#00ff00' },
+ *       { pos: 1.0, color: '#ff0000' }
+ *     ]}
+ *     levels={16}
+ *     contourColor="#ffffff"
+ *   />
+ * </Map>
+ * ```
+ *
+ * ## Rendering Pipeline
+ *
+ * Uses a two-pass WebGL rendering approach:
+ *
+ * 1. **Pass 1 (off-screen):** Renders triangulated data to a 1024×1024 texture
+ *    as grayscale values (normalized 0-1)
+ * 2. **Pass 2 (on-screen):** Reads the texture, applies gradient colors, and
+ *    optionally draws contour lines by detecting edges between shade levels
+ *
+ * ## Contour Detection
+ *
+ * Contour lines are drawn where adjacent pixels have different "shade levels".
+ * The `levels` prop controls quantization—higher values produce more contour lines.
+ * Set `levels={0}` to disable contour lines entirely.
+ *
+ * ## Data Requirements
+ *
+ * - Minimum 3 points required for triangulation
+ * - Points with `NaN` values are filtered out
+ * - Values are automatically normalized to 0-1 range
  */
 var InterpolationLayer = function (_a) {
-    var _b = _a.levels, levels = _b === void 0 ? 0 : _b, _c = _a.contourColor, contourColor = _c === void 0 ? '#35ABE2' : _c, _d = _a.gradientStops, gradientStops = _d === void 0 ? [
+    var _b = _a.levels, levels = _b === void 0 ? 0 : _b, _c = _a.contourColor, contourColor = _c === void 0 ? '#35ABE2' : _c, _d = _a.contourThickness, contourThickness = _d === void 0 ? 1 : _d, _e = _a.gradientStops, gradientStops = _e === void 0 ? [
         { pos: 0.0, color: '#0000ffff' },
         { pos: 1.0, color: '#000000ff' }
-    ] : _d, _e = _a.minZoom, minZoom = _e === void 0 ? 0 : _e, _f = _a.maxZoom, maxZoom = _f === void 0 ? 99 : _f, _g = _a.dots, dots = _g === void 0 ? false : _g, props = __rest(_a, ["levels", "contourColor", "gradientStops", "minZoom", "maxZoom", "dots"]);
-    return React.createElement(InterpolationLayerBase, __assign({ levels: levels, contourColor: contourColor, gradientStops: gradientStops, minZoom: minZoom, maxZoom: maxZoom, dots: dots }, props));
+    ] : _e, _f = _a.minZoom, minZoom = _f === void 0 ? 0 : _f, _g = _a.maxZoom, maxZoom = _g === void 0 ? 99 : _g, _h = _a.dots, dots = _h === void 0 ? false : _h, props = __rest(_a, ["levels", "contourColor", "contourThickness", "gradientStops", "minZoom", "maxZoom", "dots"]);
+    return React.createElement(InterpolationLayerBase, __assign({ levels: levels, contourColor: contourColor, contourThickness: contourThickness, gradientStops: gradientStops, minZoom: minZoom, maxZoom: maxZoom, dots: dots }, props));
 };
 InterpolationLayer.displayName = 'InterpolationLayer';
 export { InterpolationLayer };

package/map/layers/InterpolationLayer/index.d.ts

@@ -1 +1,2 @@
-export * from './InterpolationLayer';
+export { InterpolationLayer } from './InterpolationLayer';
+export type { IInterpolationLayerProps } from './InterpolationLayer';

package/map/layers/InterpolationLayer/index.js

@@ -1 +1 @@
-export * from './InterpolationLayer';
+export { InterpolationLayer } from './InterpolationLayer';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longline/aqua-ui",
-  "version": "1.0.303",
+  "version": "1.0.307",
   "description": "AquaUI",
   "author": "Alexander van Oostenrijk / Longline Environment",
   "license": "Commercial",