@kepler.gl/components 3.1.0-alpha.0 → 3.1.0-alpha.2

package/dist/side-panel/layer-panel/layer-error-message.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare type LayerErrorMessageProps = {
+    errorMessage: string;
+};
+declare const LayerErrorMessage: React.FC<LayerErrorMessageProps>;
+export default LayerErrorMessage;

package/dist/side-panel/layer-panel/layer-error-message.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireDefault(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _localization = require("@kepler.gl/localization");
+var _templateObject; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var LayerErrorMessageContent = _styledComponents["default"].div.attrs({
+  className: 'layer-error-message-content'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  background-color: ", ";\n  color: #fff;\n  display: block;\n  width: 100%;\n  font-size: 11px;\n  padding: 1em;\n  border-radius: 4px;\n"])), function (props) {
+  return props.theme.notificationColors.error || '#000';
+});
+var LayerErrorMessage = function LayerErrorMessage(_ref) {
+  var errorMessage = _ref.errorMessage;
+  return /*#__PURE__*/_react["default"].createElement(LayerErrorMessageContent, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: 'layer.layerUpdateError',
+    values: {
+      errorMessage: errorMessage
+    }
+  }));
+};
+var _default = exports["default"] = LayerErrorMessage;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/layer-panel/layer-list.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Layer, LayerClassesType } from '@kepler.gl/layers';
+import { Datasets } from '@kepler.gl/table';
+import { UIStateActions, VisStateActions, MapStateActions } from '@kepler.gl/actions';
+import LayerPanelFactory from './layer-panel';
+export declare type LayerListProps = {
+    datasets: Datasets;
+    layers: Layer[];
+    layerOrder: string[];
+    layerClasses: LayerClassesType;
+    isSortable?: boolean;
+    uiStateActions: typeof UIStateActions;
+    visStateActions: typeof VisStateActions;
+    mapStateActions: typeof MapStateActions;
+};
+export declare type LayerListFactoryDeps = [typeof LayerPanelFactory];
+declare function LayerListFactory(LayerPanel: ReturnType<typeof LayerPanelFactory>): React.FC<LayerListProps>;
+declare namespace LayerListFactory {
+    var deps: (typeof LayerPanelFactory)[];
+}
+export default LayerListFactory;

package/dist/side-panel/layer-panel/layer-list.js

@@ -0,0 +1,170 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _classnames3 = _interopRequireDefault(require("classnames"));
+var _sortable = require("@dnd-kit/sortable");
+var _utilities = require("@dnd-kit/utilities");
+var _layerPanel = _interopRequireDefault(require("./layer-panel"));
+var _utils = require("@kepler.gl/utils");
+var _constants = require("@kepler.gl/constants");
+var _templateObject, _templateObject2; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// make sure the element is always visible while is being dragged
+// item being dragged is appended in body, here to reset its global style
+
+var Container = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  flex-direction: column;\n  gap: 8px;\n"])));
+var SortableStyledItem = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  z-index: ", ";\n  transition: ", ";\n  transform: ", ";\n  &.sorting {\n    opacity: 0.3;\n    pointer-events: none;\n  }\n  &.sorting-layers .layer-panel__header {\n    background-color: ", ";\n    font-family: ", ";\n    font-weight: ", ";\n    font-size: ", ";\n    line-height: ", ";\n    *,\n    *:before,\n    *:after {\n      box-sizing: border-box;\n    }\n    .layer__drag-handle {\n      opacity: 1;\n      color: ", ";\n    }\n  }\n"])), function (props) {
+  return props.theme.dropdownWrapperZ + 1;
+}, function (props) {
+  return props.transition;
+}, function (props) {
+  return props.transform;
+}, function (props) {
+  return props.theme.panelBackgroundHover;
+}, function (props) {
+  return props.theme.fontFamily;
+}, function (props) {
+  return props.theme.fontWeight;
+}, function (props) {
+  return props.theme.fontSize;
+}, function (props) {
+  return props.theme.lineHeight;
+}, function (props) {
+  return props.theme.textColorHl;
+});
+var INITIAL_LAYERS_TO_SHOW = [];
+LayerListFactory.deps = [_layerPanel["default"]];
+function LayerListFactory(LayerPanel) {
+  // By wrapping layer panel using a sortable element we don't have to implement the drag and drop logic into the panel itself;
+  // Developers can provide any layer panel implementation and it will still be sortable
+  var SortableItem = function SortableItem(_ref) {
+    var layer = _ref.layer,
+      idx = _ref.idx,
+      panelProps = _ref.panelProps,
+      layerActions = _ref.layerActions,
+      disabled = _ref.disabled;
+    var _useSortable = (0, _sortable.useSortable)({
+        id: layer.id,
+        data: {
+          type: _constants.SORTABLE_LAYER_TYPE,
+          parent: _constants.SORTABLE_SIDE_PANEL_TYPE
+        },
+        disabled: disabled
+      }),
+      attributes = _useSortable.attributes,
+      listeners = _useSortable.listeners,
+      setNodeRef = _useSortable.setNodeRef,
+      isDragging = _useSortable.isDragging,
+      transform = _useSortable.transform,
+      transition = _useSortable.transition;
+    return /*#__PURE__*/_react["default"].createElement(SortableStyledItem, (0, _extends2["default"])({
+      ref: setNodeRef,
+      className: (0, _classnames3["default"])((0, _defineProperty2["default"])({}, _constants.dataTestIds.sortableLayerItem, !disabled), (0, _defineProperty2["default"])({}, _constants.dataTestIds.staticLayerItem, disabled), {
+        sorting: isDragging
+      }),
+      "data-testid": disabled ? _constants.dataTestIds.staticLayerItem : _constants.dataTestIds.sortableLayerItem,
+      transform: _utilities.CSS.Transform.toString(transform),
+      transition: transition
+    }, attributes), /*#__PURE__*/_react["default"].createElement(LayerPanel, (0, _extends2["default"])({}, panelProps, layerActions, {
+      key: layer.id,
+      idx: idx,
+      layer: layer,
+      listeners: listeners,
+      isDraggable: !disabled
+    })));
+  };
+  var LayerList = function LayerList(props) {
+    var layers = props.layers,
+      datasets = props.datasets,
+      layerOrder = props.layerOrder,
+      uiStateActions = props.uiStateActions,
+      visStateActions = props.visStateActions,
+      mapStateActions = props.mapStateActions,
+      layerClasses = props.layerClasses,
+      _props$isSortable = props.isSortable,
+      isSortable = _props$isSortable === void 0 ? true : _props$isSortable;
+    var openModal = uiStateActions.toggleModal;
+    var layersToShow = (0, _react.useMemo)(function () {
+      return layerOrder.reduce(function (acc, layerId) {
+        var layer = (0, _utils.findById)(layerId)(layers.filter(Boolean));
+        if (!layer) {
+          return acc;
+        }
+        return !layer.config.hidden ? [].concat((0, _toConsumableArray2["default"])(acc), [layer]) : acc;
+      }, INITIAL_LAYERS_TO_SHOW);
+    }, [layers, layerOrder]);
+    var sidePanelDndItems = (0, _react.useMemo)(function () {
+      return layersToShow.map(function (_ref2) {
+        var id = _ref2.id;
+        return id;
+      });
+    }, [layersToShow]);
+    var layerTypeOptions = (0, _react.useMemo)(function () {
+      return Object.keys(layerClasses).map(function (key) {
+        var layer = new layerClasses[key]({
+          dataId: ''
+        });
+        return {
+          id: key,
+          label: layer.name,
+          icon: layer.layerIcon,
+          requireData: layer.requireData
+        };
+      });
+    }, [layerClasses]);
+    var layerActions = (0, _react.useMemo)(function () {
+      return {
+        layerColorUIChange: visStateActions.layerColorUIChange,
+        layerConfigChange: visStateActions.layerConfigChange,
+        layerVisualChannelConfigChange: visStateActions.layerVisualChannelConfigChange,
+        layerTypeChange: visStateActions.layerTypeChange,
+        layerVisConfigChange: visStateActions.layerVisConfigChange,
+        layerTextLabelChange: visStateActions.layerTextLabelChange,
+        removeLayer: visStateActions.removeLayer,
+        zoomToLayer: mapStateActions.fitBounds,
+        duplicateLayer: visStateActions.duplicateLayer,
+        layerSetIsValid: visStateActions.layerSetIsValid
+      };
+    }, [visStateActions, mapStateActions]);
+    var panelProps = (0, _react.useMemo)(function () {
+      return {
+        datasets: datasets,
+        openModal: openModal,
+        layerTypeOptions: layerTypeOptions
+      };
+    }, [datasets, openModal, layerTypeOptions]);
+    return /*#__PURE__*/_react["default"].createElement(Container, null, /*#__PURE__*/_react["default"].createElement(_sortable.SortableContext, {
+      id: _constants.SORTABLE_SIDE_PANEL_TYPE,
+      items: sidePanelDndItems,
+      strategy: _sortable.verticalListSortingStrategy,
+      disabled: !isSortable
+    }, layersToShow.map(function (layer) {
+      return /*#__PURE__*/_react["default"].createElement(SortableItem, {
+        key: layer.id,
+        layer: layer,
+        idx: layers.findIndex(function (l) {
+          return (l === null || l === void 0 ? void 0 : l.id) === layer.id;
+        }),
+        panelProps: panelProps,
+        layerActions: layerActions,
+        disabled: !isSortable
+      });
+    })));
+  };
+  return LayerList;
+}
+var _default = exports["default"] = LayerListFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_interopRequireDefault","_classnames3","_sortable","_utilities","_layerPanel","_utils","_constants","_templateObject","_templateObject2","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","Container","styled","div","_taggedTemplateLiteral2","SortableStyledItem","props","theme","dropdownWrapperZ","transition","transform","panelBackgroundHover","fontFamily","fontWeight","fontSize","lineHeight","textColorHl","INITIAL_LAYERS_TO_SHOW","LayerListFactory","deps","LayerPanelFactory","LayerPanel","SortableItem","_ref","layer","idx","panelProps","layerActions","disabled","_useSortable","useSortable","id","data","type","SORTABLE_LAYER_TYPE","parent","SORTABLE_SIDE_PANEL_TYPE","attributes","listeners","setNodeRef","isDragging","createElement","_extends2","ref","className","classnames","_defineProperty2","dataTestIds","sortableLayerItem","staticLayerItem","sorting","CSS","Transform","toString","key","isDraggable","LayerList","layers","datasets","layerOrder","uiStateActions","visStateActions","mapStateActions","layerClasses","_props$isSortable","isSortable","openModal","toggleModal","layersToShow","useMemo","reduce","acc","layerId","findById","filter","Boolean","config","hidden","concat","_toConsumableArray2","sidePanelDndItems","map","_ref2","layerTypeOptions","keys","dataId","label","name","icon","layerIcon","requireData","layerColorUIChange","layerConfigChange","layerVisualChannelConfigChange","layerTypeChange","layerVisConfigChange","layerTextLabelChange","removeLayer","zoomToLayer","fitBounds","duplicateLayer","layerSetIsValid","SortableContext","items","strategy","verticalListSortingStrategy","findIndex","l","_default","exports"],"sources":["../../../src/side-panel/layer-panel/layer-list.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo} from 'react';\nimport styled from 'styled-components';\nimport classnames from 'classnames';\n\nimport {Layer, LayerClassesType} from '@kepler.gl/layers';\nimport {Datasets} from '@kepler.gl/table';\nimport {UIStateActions, VisStateActions, MapStateActions} from '@kepler.gl/actions';\n\nimport {useSortable, SortableContext, verticalListSortingStrategy} from '@dnd-kit/sortable';\nimport {CSS} from '@dnd-kit/utilities';\nimport LayerPanelFactory from './layer-panel';\nimport {findById} from '@kepler.gl/utils';\nimport {dataTestIds, SORTABLE_LAYER_TYPE, SORTABLE_SIDE_PANEL_TYPE} from '@kepler.gl/constants';\n\nexport type LayerListProps = {\n  datasets: Datasets;\n  layers: Layer[];\n  layerOrder: string[];\n  layerClasses: LayerClassesType;\n  isSortable?: boolean;\n  uiStateActions: typeof UIStateActions;\n  visStateActions: typeof VisStateActions;\n  mapStateActions: typeof MapStateActions;\n};\n\nexport type LayerListFactoryDeps = [typeof LayerPanelFactory];\n\n// make sure the element is always visible while is being dragged\n// item being dragged is appended in body, here to reset its global style\n\nconst Container = styled.div`\n  display: flex;\n  flex-direction: column;\n  gap: 8px;\n`;\n\ninterface SortableStyledItemProps {\n  transition?: string;\n  transform?: string;\n}\n\nconst SortableStyledItem = styled.div<SortableStyledItemProps>`\n  z-index: ${props => props.theme.dropdownWrapperZ + 1};\n  transition: ${props => props.transition};\n  transform: ${props => props.transform};\n  &.sorting {\n    opacity: 0.3;\n    pointer-events: none;\n  }\n  &.sorting-layers .layer-panel__header {\n    background-color: ${props => props.theme.panelBackgroundHover};\n    font-family: ${props => props.theme.fontFamily};\n    font-weight: ${props => props.theme.fontWeight};\n    font-size: ${props => props.theme.fontSize};\n    line-height: ${props => props.theme.lineHeight};\n    *,\n    *:before,\n    *:after {\n      box-sizing: border-box;\n    }\n    .layer__drag-handle {\n      opacity: 1;\n      color: ${props => props.theme.textColorHl};\n    }\n  }\n`;\n\nconst INITIAL_LAYERS_TO_SHOW: Layer[] = [];\n\nLayerListFactory.deps = [LayerPanelFactory];\n\nfunction LayerListFactory(LayerPanel: ReturnType<typeof LayerPanelFactory>) {\n  // By wrapping layer panel using a sortable element we don't have to implement the drag and drop logic into the panel itself;\n  // Developers can provide any layer panel implementation and it will still be sortable\n  const SortableItem = ({layer, idx, panelProps, layerActions, disabled}) => {\n    const {attributes, listeners, setNodeRef, isDragging, transform, transition} = useSortable({\n      id: layer.id,\n      data: {\n        type: SORTABLE_LAYER_TYPE,\n        parent: SORTABLE_SIDE_PANEL_TYPE\n      },\n      disabled\n    });\n\n    return (\n      <SortableStyledItem\n        ref={setNodeRef}\n        className={classnames(\n          {[dataTestIds.sortableLayerItem]: !disabled},\n          {[dataTestIds.staticLayerItem]: disabled},\n          {sorting: isDragging}\n        )}\n        data-testid={disabled ? dataTestIds.staticLayerItem : dataTestIds.sortableLayerItem}\n        transform={CSS.Transform.toString(transform)}\n        transition={transition}\n        {...attributes}\n      >\n        <LayerPanel\n          {...panelProps}\n          {...layerActions}\n          key={layer.id}\n          idx={idx}\n          layer={layer}\n          listeners={listeners}\n          isDraggable={!disabled}\n        />\n      </SortableStyledItem>\n    );\n  };\n\n  const LayerList: React.FC<LayerListProps> = props => {\n    const {\n      layers,\n      datasets,\n      layerOrder,\n      uiStateActions,\n      visStateActions,\n      mapStateActions,\n      layerClasses,\n      isSortable = true\n    } = props;\n    const {toggleModal: openModal} = uiStateActions;\n\n    const layersToShow = useMemo(() => {\n      return layerOrder.reduce((acc, layerId) => {\n        const layer = findById(layerId)(layers.filter(Boolean));\n        if (!layer) {\n          return acc;\n        }\n        return !layer.config.hidden ? [...acc, layer] : acc;\n      }, INITIAL_LAYERS_TO_SHOW);\n    }, [layers, layerOrder]);\n\n    const sidePanelDndItems = useMemo(() => {\n      return layersToShow.map(({id}) => id);\n    }, [layersToShow]);\n\n    const layerTypeOptions = useMemo(\n      () =>\n        Object.keys(layerClasses).map(key => {\n          const layer = new layerClasses[key]({dataId: ''});\n          return {\n            id: key,\n            label: layer.name,\n            icon: layer.layerIcon,\n            requireData: layer.requireData\n          };\n        }),\n      [layerClasses]\n    );\n\n    const layerActions = useMemo(\n      () => ({\n        layerColorUIChange: visStateActions.layerColorUIChange,\n        layerConfigChange: visStateActions.layerConfigChange,\n        layerVisualChannelConfigChange: visStateActions.layerVisualChannelConfigChange,\n        layerTypeChange: visStateActions.layerTypeChange,\n        layerVisConfigChange: visStateActions.layerVisConfigChange,\n        layerTextLabelChange: visStateActions.layerTextLabelChange,\n        removeLayer: visStateActions.removeLayer,\n        zoomToLayer: mapStateActions.fitBounds,\n        duplicateLayer: visStateActions.duplicateLayer,\n        layerSetIsValid: visStateActions.layerSetIsValid\n      }),\n      [visStateActions, mapStateActions]\n    );\n\n    const panelProps = useMemo(\n      () => ({\n        datasets,\n        openModal,\n        layerTypeOptions\n      }),\n      [datasets, openModal, layerTypeOptions]\n    );\n\n    return (\n      <Container>\n        <SortableContext\n          id={SORTABLE_SIDE_PANEL_TYPE}\n          items={sidePanelDndItems}\n          strategy={verticalListSortingStrategy}\n          disabled={!isSortable}\n        >\n          {/* warning: containerId should be similar to the first key in dndItems defined in kepler-gl.js*/}\n          {layersToShow.map(layer => (\n            <SortableItem\n              key={layer.id}\n              layer={layer}\n              idx={layers.findIndex(l => l?.id === layer.id)}\n              panelProps={panelProps}\n              layerActions={layerActions}\n              disabled={!isSortable}\n            />\n          ))}\n        </SortableContext>\n      </Container>\n    );\n  };\n  return LayerList;\n}\nexport default LayerListFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/side-panel/layer-panel/layer-panel-header.d.ts

@@ -0,0 +1,73 @@
+import React, { ComponentType, MouseEventHandler, ChangeEventHandler } from 'react';
+import PanelHeaderActionFactory from '../panel-header-action';
+import { RGBColor } from '@kepler.gl/types';
+import { BaseProps } from '../../common/icons';
+export declare type LayerLabelEditorProps = {
+    layerId: string;
+    label?: string;
+    onEdit: ChangeEventHandler;
+    onFocus: ChangeEventHandler;
+    onBlur: ChangeEventHandler;
+};
+export declare type LayerTitleSectionProps = {
+    layerType?: string | null;
+    layerId: string;
+    label?: string;
+    onUpdateLayerLabel: ChangeEventHandler;
+    onFocus: ChangeEventHandler;
+    onBlur: ChangeEventHandler;
+};
+export declare type LayerPanelHeaderProps = {
+    layerId: string;
+    isVisible: boolean;
+    isValid: boolean;
+    onToggleVisibility: MouseEventHandler;
+    onUpdateLayerLabel: ChangeEventHandler;
+    onToggleEnableConfig: MouseEventHandler;
+    onRemoveLayer: MouseEventHandler;
+    onZoomToLayer: MouseEventHandler;
+    onDuplicateLayer: MouseEventHandler;
+    onResetIsValid: MouseEventHandler;
+    isConfigActive: boolean;
+    showRemoveLayer?: boolean;
+    label?: string;
+    layerType?: string | null;
+    allowDuplicate?: boolean;
+    isDragNDropEnabled?: boolean;
+    warning?: boolean;
+    labelRCGColorValues?: RGBColor | null;
+    actionIcons?: {
+        remove: ComponentType<Partial<BaseProps>>;
+        visible: ComponentType<Partial<BaseProps>>;
+        hidden: ComponentType<Partial<BaseProps>>;
+        enableConfig: ComponentType<Partial<BaseProps>>;
+        resetIsValid: ComponentType<Partial<BaseProps>>;
+        duplicate: ComponentType<Partial<BaseProps>>;
+        crosshairs: ComponentType<Partial<BaseProps>>;
+    };
+    listeners?: React.ElementType;
+};
+declare type HeaderActionSectionProps = {
+    isEditingLabel: boolean;
+};
+export declare type LayerPanelHeaderActionSectionProps = LayerPanelHeaderProps & HeaderActionSectionProps;
+export declare const DragHandle: React.FC<{
+    className?: string;
+    listeners?: any;
+    children?: React.ReactNode;
+}>;
+export declare const LayerLabelEditor: React.FC<LayerLabelEditorProps>;
+export declare function LayerTitleSectionFactory(): React.FC<LayerTitleSectionProps>;
+export declare function LayerPanelHeaderActionSectionFactory(PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): React.FC<LayerPanelHeaderActionSectionProps>;
+export declare namespace LayerPanelHeaderActionSectionFactory {
+    var deps: (typeof PanelHeaderActionFactory)[];
+}
+export declare const HeaderWarning: ({ warning, id }: {
+    warning: any;
+    id: any;
+}) => React.JSX.Element;
+declare function LayerPanelHeaderFactory(LayerTitleSection: ReturnType<typeof LayerTitleSectionFactory>, LayerPanelHeaderActionSection: ReturnType<typeof LayerPanelHeaderActionSectionFactory>): React.FC<LayerPanelHeaderProps>;
+declare namespace LayerPanelHeaderFactory {
+    var deps: (typeof LayerPanelHeaderActionSectionFactory | typeof LayerTitleSectionFactory)[];
+}
+export default LayerPanelHeaderFactory;