@kepler.gl/components 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/esm/effects/effect-list.js

@@ -0,0 +1,122 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled from 'styled-components';
+import classnames from 'classnames';
+import { CSS } from '@dnd-kit/utilities';
+import { useSortable, SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable';
+import { dataTestIds } from '@kepler.gl/constants';
+import { findById } from '@kepler.gl/utils';
+import { SORTABLE_EFFECT_TYPE, SORTABLE_EFFECT_PANEL_TYPE } from '../common/dnd-layer-items';
+import EffectPanelFactory from './effect-panel';
+var Container = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n"])));
+var SortableStyledItem = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  z-index: ", ";\n  transition: ", ";\n  transform: ", ";\n  outline: none;\n  &.sorting {\n    opacity: 0.3;\n    pointer-events: none;\n  }\n  &.sorting-effects .effect-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    .effect__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;
+});
+EffectListFactory.deps = [EffectPanelFactory];
+function EffectListFactory(EffectPanel) {
+  var SortableItem = function SortableItem(_ref) {
+    var effect = _ref.effect,
+      idx = _ref.idx,
+      panelProps = _ref.panelProps,
+      disabled = _ref.disabled;
+    var _useSortable = useSortable({
+        id: effect.id,
+        data: {
+          type: SORTABLE_EFFECT_TYPE,
+          parent: SORTABLE_EFFECT_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.createElement(SortableStyledItem, _extends({
+      ref: setNodeRef,
+      className: classnames(_defineProperty({}, dataTestIds.sortableEffectItem, !disabled), _defineProperty({}, dataTestIds.staticEffectItem, disabled), {
+        sorting: isDragging
+      }),
+      "data-testid": disabled ? dataTestIds.staticEffectItem : dataTestIds.sortableEffectItem,
+      transform: CSS.Transform.toString(transform),
+      transition: transition || ''
+    }, attributes), /*#__PURE__*/React.createElement(EffectPanel, _extends({}, panelProps, {
+      key: effect.id,
+      idx: idx,
+      effect: effect,
+      listeners: listeners,
+      isDraggable: !disabled
+    })));
+  };
+  var EffectList = function EffectList(props) {
+    var effects = props.effects,
+      effectOrder = props.effectOrder,
+      visStateActions = props.visStateActions;
+    var effectsToShow = useMemo(function () {
+      return effectOrder.reduce(function (acc, effectId) {
+        var effect = findById(effectId)(effects.filter(Boolean));
+        if (!effect) {
+          return acc;
+        }
+        return [].concat(_toConsumableArray(acc), [effect]);
+      }, []);
+    }, [effects, effectOrder]);
+    var sidePanelDndItems = useMemo(function () {
+      return effectsToShow.map(function (_ref2) {
+        var id = _ref2.id;
+        return id;
+      });
+    }, [effectsToShow]);
+    var panelProps = useMemo(function () {
+      return {
+        effects: effects,
+        effectOrder: effectOrder,
+        removeEffect: visStateActions.removeEffect,
+        updateEffect: visStateActions.updateEffect
+      };
+    }, [effects, effectOrder, visStateActions]);
+    return /*#__PURE__*/React.createElement(Container, null, /*#__PURE__*/React.createElement(SortableContext, {
+      id: SORTABLE_EFFECT_PANEL_TYPE,
+      items: sidePanelDndItems,
+      strategy: verticalListSortingStrategy,
+      disabled: false
+    }, effectsToShow.map(function (effect) {
+      return /*#__PURE__*/React.createElement(SortableItem, {
+        key: effect.id,
+        effect: effect,
+        idx: effects.findIndex(function (l) {
+          return (l === null || l === void 0 ? void 0 : l.id) === effect.id;
+        }),
+        panelProps: panelProps,
+        disabled: false
+      });
+    })));
+  };
+  return EffectList;
+}
+export default EffectListFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","styled","classnames","CSS","useSortable","SortableContext","verticalListSortingStrategy","dataTestIds","findById","SORTABLE_EFFECT_TYPE","SORTABLE_EFFECT_PANEL_TYPE","EffectPanelFactory","Container","div","_templateObject","_taggedTemplateLiteral","SortableStyledItem","_templateObject2","props","theme","dropdownWrapperZ","transition","transform","panelBackgroundHover","fontFamily","fontWeight","fontSize","lineHeight","textColorHl","EffectListFactory","deps","EffectPanel","SortableItem","_ref","effect","idx","panelProps","disabled","_useSortable","id","data","type","parent","attributes","listeners","setNodeRef","isDragging","createElement","_extends","ref","className","_defineProperty","sortableEffectItem","staticEffectItem","sorting","Transform","toString","key","isDraggable","EffectList","effects","effectOrder","visStateActions","effectsToShow","reduce","acc","effectId","filter","Boolean","concat","_toConsumableArray","sidePanelDndItems","map","_ref2","removeEffect","updateEffect","items","strategy","findIndex","l"],"sources":["../../../src/effects/effect-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';\nimport {CSS} from '@dnd-kit/utilities';\nimport {useSortable, SortableContext, verticalListSortingStrategy} from '@dnd-kit/sortable';\n\nimport {dataTestIds} from '@kepler.gl/constants';\nimport {findById} from '@kepler.gl/utils';\nimport {Effect} from '@kepler.gl/types';\nimport {\n  addEffect,\n  updateEffect,\n  removeEffect,\n  reorderEffect,\n  ActionHandler\n} from '@kepler.gl/actions';\n\nimport {SORTABLE_EFFECT_TYPE, SORTABLE_EFFECT_PANEL_TYPE} from '../common/dnd-layer-items';\nimport EffectPanelFactory from './effect-panel';\n\nexport type EffectListProps = {\n  effects: Effect[];\n  effectOrder: string[];\n  visStateActions: {\n    addEffect: ActionHandler<typeof addEffect>;\n    updateEffect: ActionHandler<typeof updateEffect>;\n    removeEffect: ActionHandler<typeof removeEffect>;\n    reorderEffect: ActionHandler<typeof reorderEffect>;\n  };\n  isSortable: boolean;\n};\n\nconst Container = styled.div`\n  display: flex;\n  flex-direction: column;\n`;\n\ntype SortableStyledItemProps = {transition?: string; transform?: string};\nconst SortableStyledItem = styled.div<SortableStyledItemProps>`\n  z-index: ${props => props.theme.dropdownWrapperZ + 1};\n  transition: ${props => props.transition};\n  transform: ${props => props.transform};\n  outline: none;\n  &.sorting {\n    opacity: 0.3;\n    pointer-events: none;\n  }\n  &.sorting-effects .effect-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    .effect__drag-handle {\n      opacity: 1;\n      color: ${props => props.theme.textColorHl};\n    }\n  }\n`;\n\nEffectListFactory.deps = [EffectPanelFactory];\n\nfunction EffectListFactory(\n  EffectPanel: ReturnType<typeof EffectPanelFactory>\n): React.FC<EffectListProps> {\n  const SortableItem = ({effect, idx, panelProps, disabled}) => {\n    const {attributes, listeners, setNodeRef, isDragging, transform, transition} = useSortable({\n      id: effect.id,\n      data: {\n        type: SORTABLE_EFFECT_TYPE,\n        parent: SORTABLE_EFFECT_PANEL_TYPE\n      },\n      disabled\n    });\n\n    return (\n      <SortableStyledItem\n        ref={setNodeRef}\n        className={classnames(\n          {[dataTestIds.sortableEffectItem]: !disabled},\n          {[dataTestIds.staticEffectItem]: disabled},\n          {sorting: isDragging}\n        )}\n        data-testid={disabled ? dataTestIds.staticEffectItem : dataTestIds.sortableEffectItem}\n        transform={CSS.Transform.toString(transform)}\n        transition={transition || ''}\n        {...attributes}\n      >\n        <EffectPanel\n          {...panelProps}\n          key={effect.id}\n          idx={idx}\n          effect={effect}\n          listeners={listeners}\n          isDraggable={!disabled}\n        />\n      </SortableStyledItem>\n    );\n  };\n\n  const EffectList = (props: EffectListProps) => {\n    const {effects, effectOrder, visStateActions} = props;\n\n    const effectsToShow = useMemo(() => {\n      return effectOrder.reduce((acc, effectId) => {\n        const effect = findById(effectId)(effects.filter(Boolean));\n        if (!effect) {\n          return acc;\n        }\n        return [...acc, effect];\n      }, [] as Effect[]);\n    }, [effects, effectOrder]);\n\n    const sidePanelDndItems = useMemo(() => {\n      return effectsToShow.map(({id}) => id);\n    }, [effectsToShow]);\n\n    const panelProps = useMemo(\n      () => ({\n        effects,\n        effectOrder,\n        removeEffect: visStateActions.removeEffect,\n        updateEffect: visStateActions.updateEffect\n      }),\n      [effects, effectOrder, visStateActions]\n    );\n\n    return (\n      <Container>\n        <SortableContext\n          id={SORTABLE_EFFECT_PANEL_TYPE}\n          items={sidePanelDndItems}\n          strategy={verticalListSortingStrategy}\n          disabled={false}\n        >\n          {effectsToShow.map(effect => (\n            <SortableItem\n              key={effect.id}\n              effect={effect}\n              idx={effects.findIndex(l => l?.id === effect.id)}\n              panelProps={panelProps}\n              disabled={false}\n            />\n          ))}\n        </SortableContext>\n      </Container>\n    );\n  };\n  return EffectList;\n}\n\nexport default EffectListFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/effects/effect-manager.js

@@ -0,0 +1,119 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo, useState, useCallback } from 'react';
+import styled from 'styled-components';
+import { injectIntl } from 'react-intl';
+import { addEffect, updateEffect, removeEffect, reorderEffect } from '@kepler.gl/actions';
+import { LIGHT_AND_SHADOW_EFFECT, EFFECT_DESCRIPTIONS, DISTANCE_FOG_TYPE, SURFACE_FOG_TYPE } from '@kepler.gl/constants';
+import { visStateLens } from '@kepler.gl/reducers';
+import { withState } from '../injector';
+import SidePanelTitleFactory from './side-panel-title';
+import EffectListFactory from './effect-list';
+import EffectTypeSelectorFactory from './effect-type-selector';
+var StyledEffectPanelContainer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  pointer-events: none !important; /* prevent padding from blocking input */\n  flex-grow: 1;\n  justify-content: space-between;\n  overflow: hidden;\n\n  & > * {\n    /* all children should allow input */\n    pointer-events: all;\n  }\n"])));
+
+// top right position absolute
+var StyledEffectPanel = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  top: 0;\n  background-color: ", ";\n  display: flex;\n  flex-direction: column;\n  flex-grow: 1;\n  overflow: hidden;\n"])), function (props) {
+  return props.theme.sidePanelBg;
+});
+var StyledEffectPanelHeader = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  padding: ", ";\n  border-bottom: 1px solid ", ";\n  min-width: ", "px;\n"])), function (_ref) {
+  var theme = _ref.theme;
+  return "".concat(theme.effectPanelPaddingTop, "px ").concat(theme.effectPanelPaddingSide, "px 4px ").concat(theme.effectPanelPaddingSide, "px");
+}, function (props) {
+  return props.theme.borderColor;
+}, function (_ref2) {
+  var theme = _ref2.theme;
+  return theme.effectPanelWidth;
+});
+var StyledEffectPanelContent = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  ", ";\n  padding: ", ";\n  overflow: overlay;\n  display: flex;\n  flex-direction: column;\n"])), function (props) {
+  return props.theme.sidePanelScrollBar;
+}, function (props) {
+  return props.$extended ? '32px' : '10px 0px 10px 0px';
+});
+EffectManagerFactory.deps = [EffectListFactory, SidePanelTitleFactory, EffectTypeSelectorFactory];
+function EffectManagerFactory(EffectList, SidePanelTitle, EffectTypeSelector) {
+  var EffectManager = function EffectManager(props) {
+    var intl = props.intl,
+      visStateActions = props.visStateActions,
+      visState = props.visState,
+      children = props.children;
+    var effects = visState.effects,
+      effectOrder = visState.effectOrder;
+    var visStateAddEffect = visStateActions.addEffect;
+    var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      typeSelectorOpened = _useState2[0],
+      setTypeSelectorOpened = _useState2[1];
+
+    // Prevent shadow effect from being added multiple times
+    var effectOptions = useMemo(function () {
+      var hasShadow = effects.some(function (effect) {
+        return effect.type === LIGHT_AND_SHADOW_EFFECT.type;
+      });
+      var hasDistanceFog = effects.some(function (effect) {
+        return effect.type === DISTANCE_FOG_TYPE;
+      });
+      var hasSurfaceFog = effects.some(function (effect) {
+        return effect.type === SURFACE_FOG_TYPE;
+      });
+      var hasAnyFog = hasDistanceFog || hasSurfaceFog;
+      return EFFECT_DESCRIPTIONS.map(function (desc) {
+        return _objectSpread(_objectSpread({}, desc), {}, {
+          disabled: Boolean(hasShadow && desc.type === LIGHT_AND_SHADOW_EFFECT.type || hasAnyFog && (desc.type === DISTANCE_FOG_TYPE || desc.type === SURFACE_FOG_TYPE))
+        });
+      });
+    }, [effects]);
+    var onAddEffect = useCallback(function (type) {
+      visStateAddEffect({
+        type: type
+      });
+    }, [visStateAddEffect]);
+    var onTypeSelectOpen = useCallback(function () {
+      setTypeSelectorOpened(true);
+    }, []);
+    var onTypeSelectClose = useCallback(function () {
+      setTypeSelectorOpened(false);
+    }, []);
+    return /*#__PURE__*/React.createElement(StyledEffectPanelContainer, {
+      className: "effect-manager"
+    }, /*#__PURE__*/React.createElement(StyledEffectPanel, null, /*#__PURE__*/React.createElement(StyledEffectPanelHeader, {
+      className: "effect-panel-header"
+    }, /*#__PURE__*/React.createElement(SidePanelTitle, {
+      className: "effect-manager-title",
+      title: intl.formatMessage({
+        id: 'effectManager.effects'
+      })
+    }, /*#__PURE__*/React.createElement(EffectTypeSelector, {
+      options: effectOptions,
+      onSelect: onAddEffect,
+      onOpen: onTypeSelectOpen,
+      onBlur: onTypeSelectClose
+    }))), /*#__PURE__*/React.createElement(StyledEffectPanelContent, {
+      $extended: typeSelectorOpened && effects.length === 0
+    }, /*#__PURE__*/React.createElement(EffectList, {
+      effects: effects,
+      effectOrder: effectOrder,
+      visStateActions: visStateActions,
+      isSortable: true
+    }))), children);
+  };
+  return withState([visStateLens], function (state) {
+    return state;
+  }, {
+    visStateActions: {
+      addEffect: addEffect,
+      updateEffect: updateEffect,
+      removeEffect: removeEffect,
+      reorderEffect: reorderEffect
+    }
+  })(injectIntl(EffectManager));
+}
+export default EffectManagerFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","useState","useCallback","styled","injectIntl","addEffect","updateEffect","removeEffect","reorderEffect","LIGHT_AND_SHADOW_EFFECT","EFFECT_DESCRIPTIONS","DISTANCE_FOG_TYPE","SURFACE_FOG_TYPE","visStateLens","withState","SidePanelTitleFactory","EffectListFactory","EffectTypeSelectorFactory","StyledEffectPanelContainer","div","_templateObject","_taggedTemplateLiteral","StyledEffectPanel","_templateObject2","props","theme","sidePanelBg","StyledEffectPanelHeader","_templateObject3","_ref","concat","effectPanelPaddingTop","effectPanelPaddingSide","borderColor","_ref2","effectPanelWidth","StyledEffectPanelContent","_templateObject4","sidePanelScrollBar","$extended","EffectManagerFactory","deps","EffectList","SidePanelTitle","EffectTypeSelector","EffectManager","intl","visStateActions","visState","children","effects","effectOrder","visStateAddEffect","_useState","_useState2","_slicedToArray","typeSelectorOpened","setTypeSelectorOpened","effectOptions","hasShadow","some","effect","type","hasDistanceFog","hasSurfaceFog","hasAnyFog","map","desc","_objectSpread","disabled","Boolean","onAddEffect","onTypeSelectOpen","onTypeSelectClose","createElement","className","title","formatMessage","id","options","onSelect","onOpen","onBlur","length","isSortable","state"],"sources":["../../../src/effects/effect-manager.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo, useState, useCallback} from 'react';\nimport styled from 'styled-components';\nimport {injectIntl, IntlShape} from 'react-intl';\n\nimport {\n  addEffect,\n  updateEffect,\n  removeEffect,\n  reorderEffect,\n  ActionHandler\n} from '@kepler.gl/actions';\nimport {\n  LIGHT_AND_SHADOW_EFFECT,\n  EFFECT_DESCRIPTIONS,\n  DISTANCE_FOG_TYPE,\n  SURFACE_FOG_TYPE\n} from '@kepler.gl/constants';\nimport {visStateLens} from '@kepler.gl/reducers';\nimport {Effect} from '@kepler.gl/types';\nimport {VisState} from '@kepler.gl/schemas';\n\nimport {withState} from '../injector';\nimport SidePanelTitleFactory from './side-panel-title';\nimport EffectListFactory from './effect-list';\nimport EffectTypeSelectorFactory, {EffectTypeSelectorProps} from './effect-type-selector';\n\nexport type EffectManagerState = {\n  visState: VisState;\n  visStateActions: {\n    addEffect: ActionHandler<typeof addEffect>;\n    updateEffect: ActionHandler<typeof updateEffect>;\n    removeEffect: ActionHandler<typeof removeEffect>;\n    reorderEffect: ActionHandler<typeof reorderEffect>;\n  };\n  effects: Effect[];\n  effectOrder: string[];\n  children: React.ReactNode;\n};\nexport type EffectManagerProps = EffectManagerWithIntlProp & EffectManagerState;\n\nexport type EffectManagerWithIntlProp = {intl: IntlShape};\n\nconst StyledEffectPanelContainer = styled.div`\n  display: flex;\n  flex-direction: column;\n  pointer-events: none !important; /* prevent padding from blocking input */\n  flex-grow: 1;\n  justify-content: space-between;\n  overflow: hidden;\n\n  & > * {\n    /* all children should allow input */\n    pointer-events: all;\n  }\n`;\n\n// top right position absolute\nconst StyledEffectPanel = styled.div`\n  top: 0;\n  background-color: ${props => props.theme.sidePanelBg};\n  display: flex;\n  flex-direction: column;\n  flex-grow: 1;\n  overflow: hidden;\n`;\n\nconst StyledEffectPanelHeader = styled.div`\n  padding: ${({theme}) =>\n    `${theme.effectPanelPaddingTop}px ${theme.effectPanelPaddingSide}px 4px ${theme.effectPanelPaddingSide}px`};\n  border-bottom: 1px solid ${props => props.theme.borderColor};\n  min-width: ${({theme}) => theme.effectPanelWidth}px;\n`;\n\ntype StyledEffectPanelContentProps = {\n  $extended?: boolean;\n};\nconst StyledEffectPanelContent = styled.div<StyledEffectPanelContentProps>`\n  ${props => props.theme.sidePanelScrollBar};\n  padding: ${props => (props.$extended ? '32px' : '10px 0px 10px 0px')};\n  overflow: overlay;\n  display: flex;\n  flex-direction: column;\n`;\n\nEffectManagerFactory.deps = [EffectListFactory, SidePanelTitleFactory, EffectTypeSelectorFactory];\n\nfunction EffectManagerFactory(\n  EffectList: ReturnType<typeof EffectListFactory>,\n  SidePanelTitle: ReturnType<typeof SidePanelTitleFactory>,\n  EffectTypeSelector: ReturnType<typeof EffectTypeSelectorFactory>\n): React.FC<EffectManagerProps> {\n  const EffectManager = (props: EffectManagerWithIntlProp & EffectManagerState) => {\n    const {intl, visStateActions, visState, children} = props;\n    const {effects, effectOrder} = visState;\n    const {addEffect: visStateAddEffect} = visStateActions;\n    const [typeSelectorOpened, setTypeSelectorOpened] = useState(false);\n\n    // Prevent shadow effect from being added multiple times\n    const effectOptions: EffectTypeSelectorProps['options'] = useMemo(() => {\n      const hasShadow = effects.some(effect => {\n        return effect.type === LIGHT_AND_SHADOW_EFFECT.type;\n      });\n      const hasDistanceFog = effects.some(effect => {\n        return effect.type === DISTANCE_FOG_TYPE;\n      });\n      const hasSurfaceFog = effects.some(effect => {\n        return effect.type === SURFACE_FOG_TYPE;\n      });\n      const hasAnyFog = hasDistanceFog || hasSurfaceFog;\n\n      return EFFECT_DESCRIPTIONS.map(desc => {\n        return {\n          ...desc,\n          disabled: Boolean(\n            (hasShadow && desc.type === LIGHT_AND_SHADOW_EFFECT.type) ||\n              (hasAnyFog && (desc.type === DISTANCE_FOG_TYPE || desc.type === SURFACE_FOG_TYPE))\n          )\n        };\n      });\n    }, [effects]);\n\n    const onAddEffect = useCallback(\n      type => {\n        visStateAddEffect({type});\n      },\n      [visStateAddEffect]\n    );\n\n    const onTypeSelectOpen = useCallback(() => {\n      setTypeSelectorOpened(true);\n    }, []);\n\n    const onTypeSelectClose = useCallback(() => {\n      setTypeSelectorOpened(false);\n    }, []);\n\n    return (\n      <StyledEffectPanelContainer className=\"effect-manager\">\n        <StyledEffectPanel>\n          <StyledEffectPanelHeader className=\"effect-panel-header\">\n            <SidePanelTitle\n              className=\"effect-manager-title\"\n              title={intl.formatMessage({id: 'effectManager.effects'})}\n            >\n              <EffectTypeSelector\n                options={effectOptions}\n                onSelect={onAddEffect}\n                onOpen={onTypeSelectOpen}\n                onBlur={onTypeSelectClose}\n              />\n            </SidePanelTitle>\n          </StyledEffectPanelHeader>\n\n          <StyledEffectPanelContent $extended={typeSelectorOpened && effects.length === 0}>\n            <EffectList\n              effects={effects}\n              effectOrder={effectOrder}\n              visStateActions={visStateActions}\n              isSortable={true}\n            />\n          </StyledEffectPanelContent>\n        </StyledEffectPanel>\n        {children}\n      </StyledEffectPanelContainer>\n    );\n  };\n\n  return withState([visStateLens], state => state, {\n    visStateActions: {addEffect, updateEffect, removeEffect, reorderEffect}\n  })(injectIntl(EffectManager)) as React.FC<EffectManagerProps>;\n}\n\nexport default EffectManagerFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/effects/effect-panel-header.js

@@ -0,0 +1,188 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _defaultEffectIcons, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import classnames from 'classnames';
+import styled from 'styled-components';
+import { EFFECT_DESCRIPTIONS, LIGHT_AND_SHADOW_EFFECT, POSTPROCESSING_EFFECTS, DISTANCE_FOG_TYPE, SURFACE_FOG_TYPE } from '@kepler.gl/constants';
+import { useIntl } from 'react-intl';
+import PanelHeaderActionFactory from '../side-panel/panel-header-action';
+import { ArrowDown, ArrowUp, EyeSeen, EyeUnseen, Trash, VertDots, LightAndShadowEffectIcon, InkEffectIcon, BrightnessContrastEffectIcon, HueSaturationEffectIcon, VibranceEffectIcon, SepiaEffectIcon, DotScreenEffectIcon, ColorHalftoneEffectIcon, NoiseEffectIcon, TriangleBlurEffectIcon, ZoomBlurEffectIcon, TiltShiftEffectIcon, EdgeWorkEffectIcon, VignetteEffectIcon, MagnifyEffectIcon, HexagonalPixelateEffectIcon, DistanceFogEffectIcon, SurfaceFogEffectIcon } from '../common/icons';
+import { StyledPanelHeader, Tooltip } from '../common/styled-components';
+var MultilineTooltip = styled(Tooltip)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  &.__react_component_tooltip {\n    max-width: 280px;\n    white-space: normal;\n    line-height: 1.4;\n    text-align: left;\n  }\n"])));
+export var defaultProps = {
+  isDragNDropEnabled: true
+};
+var defaultActionIcons = {
+  remove: Trash,
+  visible: EyeSeen,
+  hidden: EyeUnseen,
+  enableConfig: ArrowDown,
+  disableConfig: ArrowUp
+};
+var defaultEffectIcons = (_defaultEffectIcons = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defaultEffectIcons, LIGHT_AND_SHADOW_EFFECT.type, LightAndShadowEffectIcon), POSTPROCESSING_EFFECTS.ink.type, InkEffectIcon), POSTPROCESSING_EFFECTS.brightnessContrast.type, BrightnessContrastEffectIcon), POSTPROCESSING_EFFECTS.hueSaturation.type, HueSaturationEffectIcon), POSTPROCESSING_EFFECTS.vibrance.type, VibranceEffectIcon), POSTPROCESSING_EFFECTS.sepia.type, SepiaEffectIcon), POSTPROCESSING_EFFECTS.dotScreen.type, DotScreenEffectIcon), POSTPROCESSING_EFFECTS.colorHalftone.type, ColorHalftoneEffectIcon), POSTPROCESSING_EFFECTS.noise.type, NoiseEffectIcon), POSTPROCESSING_EFFECTS.triangleBlur.type, TriangleBlurEffectIcon), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defaultEffectIcons, POSTPROCESSING_EFFECTS.zoomBlur.type, ZoomBlurEffectIcon), POSTPROCESSING_EFFECTS.tiltShift.type, TiltShiftEffectIcon), POSTPROCESSING_EFFECTS.edgeWork.type, EdgeWorkEffectIcon), POSTPROCESSING_EFFECTS.vignette.type, VignetteEffectIcon), POSTPROCESSING_EFFECTS.magnify.type, MagnifyEffectIcon), POSTPROCESSING_EFFECTS.hexagonalPixelate.type, HexagonalPixelateEffectIcon), DISTANCE_FOG_TYPE, DistanceFogEffectIcon), SURFACE_FOG_TYPE, SurfaceFogEffectIcon));
+var StyledEffectPanelHeader = styled(StyledPanelHeader)(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  height: ", "px;\n  position: relative;\n  align-items: stretch;\n\n  .effect__drag-handle {\n    margin-left: -5px;\n    color: ", ";\n  }\n\n  .effect__drag-handle__placeholder {\n    height: 20px;\n    padding: 0px;\n    margin: 10px 10px 10px 5px;\n  }\n\n  &:hover {\n    cursor: pointer;\n    background-color: ", ";\n    .effect__drag-handle {\n      opacity: 1;\n    }\n  }\n\n  border-left: 3px solid ", ";\n"])), function (props) {
+  return props.theme.effectPanelHeaderHeight;
+}, function (props) {
+  return props.theme.textColor;
+}, function (props) {
+  return props.theme.panelBackgroundHover;
+}, function (props) {
+  return props.theme.panelBackgroundHover;
+});
+var HeaderActionSection = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  display: flex;\n  position: absolute;\n  height: 100%;\n  align-items: stretch;\n  right: 10px;\n  &:hover {\n    .effect-panel__header__actions__hidden {\n      opacity: 1;\n      background-color: ", ";\n    }\n  }\n"])), function (props) {
+  return props.theme.panelBackgroundHover;
+});
+
+// Hiden actions only show up on hover
+
+var StyledPanelHeaderHiddenActions = styled.div.attrs({
+  className: 'effect-panel__header__actions__hidden'
+})(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  opacity: 0;\n  display: flex;\n  align-items: center;\n  transition: opacity 0.4s ease, background-color 0.4s ease;\n  background-color: ", ";\n\n  &:hover {\n    opacity: 1;\n  }\n"])), function (props) {
+  return props.$isConfigActive ? props.theme.panelBackgroundHover : props.theme.panelBackground;
+});
+var StyledDragHandle = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  opacity: 0;\n  z-index: 1000;\n  &:hover {\n    cursor: move;\n    opacity: 1;\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.textColorHl;
+});
+var DragHandle = function DragHandle(_ref) {
+  var className = _ref.className,
+    listeners = _ref.listeners,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement(StyledDragHandle, _extends({
+    className: className
+  }, listeners), children);
+};
+EffectPanelHeaderActionSectionFactory.deps = [PanelHeaderActionFactory];
+export function EffectPanelHeaderActionSectionFactory(PanelHeaderAction) {
+  var EffectPanelHeaderActionSection = function EffectPanelHeaderActionSection(props) {
+    var effectId = props.effectId,
+      isEnabled = props.isEnabled,
+      isConfigActive = props.isConfigActive,
+      onToggleEnabled = props.onToggleEnabled,
+      onRemoveEffect = props.onRemoveEffect,
+      onToggleEnableConfig = props.onToggleEnableConfig,
+      actionItems = props.actionItems,
+      _props$actionIcons = props.actionIcons,
+      actionIcons = _props$actionIcons === void 0 ? defaultActionIcons : _props$actionIcons;
+    var effectActionItems = useMemo(function () {
+      return actionItems !== null && actionItems !== void 0 ? actionItems : [{
+        key: 'remove-effect',
+        isHidden: true,
+        tooltip: 'tooltip.removeEffect',
+        tooltipType: 'error',
+        onClick: onRemoveEffect,
+        icon: actionIcons.remove
+      }, {
+        key: 'visibility-toggle',
+        tooltip: isEnabled ? 'tooltip.disableEffect' : 'tooltip.enabledEffect',
+        onClick: onToggleEnabled,
+        icon: isEnabled ? actionIcons.visible : actionIcons.hidden
+      }, {
+        key: 'enable-config',
+        classNames: {
+          'is-open': isConfigActive
+        },
+        tooltip: 'tooltip.effectSettings',
+        onClick: onToggleEnableConfig,
+        icon: actionIcons.enableConfig
+      }];
+    }, [actionItems, actionIcons, isEnabled, isConfigActive, onRemoveEffect, onToggleEnabled, onToggleEnableConfig]);
+    return /*#__PURE__*/React.createElement(HeaderActionSection, {
+      className: "effect-panel__header__actions"
+    }, /*#__PURE__*/React.createElement(StyledPanelHeaderHiddenActions, {
+      $isConfigActive: isConfigActive
+    }, effectActionItems.filter(function (item) {
+      return Boolean(item.isHidden);
+    }).map(function (item) {
+      return /*#__PURE__*/React.createElement(PanelHeaderAction, {
+        key: item.key,
+        className: "effect__".concat(item.key),
+        testId: "".concat(item.key, "-action"),
+        id: effectId,
+        tooltip: item.tooltip,
+        onClick: item.onClick,
+        tooltipType: item.tooltipType,
+        IconComponent: item.icon
+      });
+    })), effectActionItems.filter(function (item) {
+      return !item.isHidden;
+    }).map(function (item) {
+      return /*#__PURE__*/React.createElement(PanelHeaderAction, {
+        key: item.key,
+        className: classnames("effect__".concat(item.key), item.classNames),
+        testId: "".concat(item.key, "-action"),
+        id: effectId,
+        tooltip: item.tooltip,
+        onClick: item.onClick,
+        tooltipType: item.tooltipType,
+        IconComponent: item.icon
+      });
+    }));
+  };
+  return EffectPanelHeaderActionSection;
+}
+var StyledEffectTitleSection = styled.div(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  margin-left: 8px;\n  flex-grow: 1;\n  align-items: center;\n  display: flex;\n  color: ", ";\n"])), function (props) {
+  return props.theme.textColor;
+});
+var IconPlaceholder = styled.div(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  width: 20px;\n  height: 20px;\n"])));
+var EffectIconWrapper = styled.div(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n  height: 18px;\n  margin: auto;\n  color: ", ";\n"])), function (props) {
+  return props.theme.textColor;
+});
+EffectPanelHeaderFactory.deps = [EffectPanelHeaderActionSectionFactory];
+function EffectPanelHeaderFactory(EffectPanelHeaderActionSection) {
+  var EffectPanelHeader = function EffectPanelHeader(props) {
+    var isConfigActive = props.isConfigActive,
+      _props$isDragNDropEna = props.isDragNDropEnabled,
+      isDragNDropEnabled = _props$isDragNDropEna === void 0 ? true : _props$isDragNDropEna,
+      type = props.type,
+      effectId = props.effectId,
+      onToggleEnableConfig = props.onToggleEnableConfig,
+      listeners = props.listeners,
+      _props$showSortHandle = props.showSortHandle,
+      showSortHandle = _props$showSortHandle === void 0 ? true : _props$showSortHandle;
+    var intl = useIntl();
+    var effectDesc = useMemo(function () {
+      return EFFECT_DESCRIPTIONS.find(function (_description) {
+        return _description.type === type;
+      });
+    }, [type]);
+    var label = (effectDesc === null || effectDesc === void 0 ? void 0 : effectDesc.name) || 'Effect';
+    var descriptionText = effectDesc !== null && effectDesc !== void 0 && effectDesc.description ? intl.formatMessage({
+      id: effectDesc.description,
+      defaultMessage: ''
+    }) : '';
+    var tooltipId = "effect-header-".concat(effectId);
+    var EffectIcon = defaultEffectIcons[type];
+    return /*#__PURE__*/React.createElement(StyledEffectPanelHeader, {
+      className: classnames('effect-panel__header', {
+        'sort--handle': !isConfigActive
+      }),
+      $active: isConfigActive,
+      onClick: onToggleEnableConfig
+    }, isDragNDropEnabled ? /*#__PURE__*/React.createElement(DragHandle, {
+      className: "effect__drag-handle",
+      listeners: listeners
+    }, showSortHandle ? /*#__PURE__*/React.createElement(VertDots, {
+      height: "20px"
+    }) : /*#__PURE__*/React.createElement(IconPlaceholder, null)) : /*#__PURE__*/React.createElement("div", {
+      className: "effect__drag-handle__placeholder"
+    }), /*#__PURE__*/React.createElement(EffectIconWrapper, null, EffectIcon ? /*#__PURE__*/React.createElement(EffectIcon, {
+      height: "18px"
+    }) : null), /*#__PURE__*/React.createElement(StyledEffectTitleSection, {
+      "data-tip": descriptionText || undefined,
+      "data-for": descriptionText ? tooltipId : undefined
+    }, label, descriptionText ? /*#__PURE__*/React.createElement(MultilineTooltip, {
+      id: tooltipId,
+      effect: "solid",
+      place: "bottom",
+      delayShow: 500
+    }, descriptionText) : null), /*#__PURE__*/React.createElement(EffectPanelHeaderActionSection, props));
+  };
+  return EffectPanelHeader;
+}
+export default EffectPanelHeaderFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","classnames","styled","EFFECT_DESCRIPTIONS","LIGHT_AND_SHADOW_EFFECT","POSTPROCESSING_EFFECTS","DISTANCE_FOG_TYPE","SURFACE_FOG_TYPE","useIntl","PanelHeaderActionFactory","ArrowDown","ArrowUp","EyeSeen","EyeUnseen","Trash","VertDots","LightAndShadowEffectIcon","InkEffectIcon","BrightnessContrastEffectIcon","HueSaturationEffectIcon","VibranceEffectIcon","SepiaEffectIcon","DotScreenEffectIcon","ColorHalftoneEffectIcon","NoiseEffectIcon","TriangleBlurEffectIcon","ZoomBlurEffectIcon","TiltShiftEffectIcon","EdgeWorkEffectIcon","VignetteEffectIcon","MagnifyEffectIcon","HexagonalPixelateEffectIcon","DistanceFogEffectIcon","SurfaceFogEffectIcon","StyledPanelHeader","Tooltip","MultilineTooltip","_templateObject","_taggedTemplateLiteral","defaultProps","isDragNDropEnabled","defaultActionIcons","remove","visible","hidden","enableConfig","disableConfig","defaultEffectIcons","_defaultEffectIcons","_defineProperty","type","ink","brightnessContrast","hueSaturation","vibrance","sepia","dotScreen","colorHalftone","noise","triangleBlur","zoomBlur","tiltShift","edgeWork","vignette","magnify","hexagonalPixelate","StyledEffectPanelHeader","_templateObject2","props","theme","effectPanelHeaderHeight","textColor","panelBackgroundHover","HeaderActionSection","div","_templateObject3","StyledPanelHeaderHiddenActions","attrs","className","_templateObject4","$isConfigActive","panelBackground","StyledDragHandle","_templateObject5","textColorHl","DragHandle","_ref","listeners","children","createElement","_extends","EffectPanelHeaderActionSectionFactory","deps","PanelHeaderAction","EffectPanelHeaderActionSection","effectId","isEnabled","isConfigActive","onToggleEnabled","onRemoveEffect","onToggleEnableConfig","actionItems","_props$actionIcons","actionIcons","effectActionItems","key","isHidden","tooltip","tooltipType","onClick","icon","classNames","filter","item","Boolean","map","concat","testId","id","IconComponent","StyledEffectTitleSection","_templateObject6","IconPlaceholder","_templateObject7","EffectIconWrapper","_templateObject8","EffectPanelHeaderFactory","EffectPanelHeader","_props$isDragNDropEna","_props$showSortHandle","showSortHandle","intl","effectDesc","find","_description","label","name","descriptionText","description","formatMessage","defaultMessage","tooltipId","EffectIcon","$active","height","undefined","effect","place","delayShow"],"sources":["../../../src/effects/effect-panel-header.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo} from 'react';\nimport classnames from 'classnames';\nimport styled from 'styled-components';\n\nimport {\n  EFFECT_DESCRIPTIONS,\n  LIGHT_AND_SHADOW_EFFECT,\n  POSTPROCESSING_EFFECTS,\n  DISTANCE_FOG_TYPE,\n  SURFACE_FOG_TYPE\n} from '@kepler.gl/constants';\nimport {useIntl} from 'react-intl';\n\nimport PanelHeaderActionFactory, {PanelHeaderActionIcon} from '../side-panel/panel-header-action';\nimport {\n  ArrowDown,\n  ArrowUp,\n  EyeSeen,\n  EyeUnseen,\n  Trash,\n  VertDots,\n  LightAndShadowEffectIcon,\n  InkEffectIcon,\n  BrightnessContrastEffectIcon,\n  HueSaturationEffectIcon,\n  VibranceEffectIcon,\n  SepiaEffectIcon,\n  DotScreenEffectIcon,\n  ColorHalftoneEffectIcon,\n  NoiseEffectIcon,\n  TriangleBlurEffectIcon,\n  ZoomBlurEffectIcon,\n  TiltShiftEffectIcon,\n  EdgeWorkEffectIcon,\n  VignetteEffectIcon,\n  MagnifyEffectIcon,\n  HexagonalPixelateEffectIcon,\n  DistanceFogEffectIcon,\n  SurfaceFogEffectIcon,\n  BaseProps\n} from '../common/icons';\nimport {StyledPanelHeader, Tooltip} from '../common/styled-components';\n\nconst MultilineTooltip = styled(Tooltip)`\n  &.__react_component_tooltip {\n    max-width: 280px;\n    white-space: normal;\n    line-height: 1.4;\n    text-align: left;\n  }\n`;\n\nexport type ActionItem = {\n  key: string;\n  isHidden?: boolean;\n  tooltip: string;\n  classNames?: Record<string, boolean>;\n  icon: PanelHeaderActionIcon;\n  tooltipType?: 'error';\n  onClick: () => void;\n};\n\nexport type EffectPanelHeaderProps = {\n  type: string;\n  listeners: any;\n  effectId: string;\n  isEnabled: boolean;\n  isConfigActive: boolean;\n  isJsonEditorActive: boolean;\n  showSortHandle?: boolean;\n  isDragNDropEnabled: boolean;\n  onToggleEnabled: () => void;\n  onRemoveEffect: () => void;\n  onToggleEnableConfig: () => void;\n  actionIcons?: {\n    remove: React.ComponentType<Partial<BaseProps>>;\n    visible: React.ComponentType<Partial<BaseProps>>;\n    hidden: React.ComponentType<Partial<BaseProps>>;\n    enableConfig: React.ComponentType<Partial<BaseProps>>;\n    disableConfig: React.ComponentType<Partial<BaseProps>>;\n  };\n  actionItems?: ActionItem[];\n};\n\nexport const defaultProps = {\n  isDragNDropEnabled: true\n};\n\nconst defaultActionIcons = {\n  remove: Trash,\n  visible: EyeSeen,\n  hidden: EyeUnseen,\n  enableConfig: ArrowDown,\n  disableConfig: ArrowUp\n};\n\nconst defaultEffectIcons = {\n  [LIGHT_AND_SHADOW_EFFECT.type]: LightAndShadowEffectIcon,\n  [POSTPROCESSING_EFFECTS.ink.type]: InkEffectIcon,\n  [POSTPROCESSING_EFFECTS.brightnessContrast.type]: BrightnessContrastEffectIcon,\n  [POSTPROCESSING_EFFECTS.hueSaturation.type]: HueSaturationEffectIcon,\n  [POSTPROCESSING_EFFECTS.vibrance.type]: VibranceEffectIcon,\n  [POSTPROCESSING_EFFECTS.sepia.type]: SepiaEffectIcon,\n  [POSTPROCESSING_EFFECTS.dotScreen.type]: DotScreenEffectIcon,\n  [POSTPROCESSING_EFFECTS.colorHalftone.type]: ColorHalftoneEffectIcon,\n  [POSTPROCESSING_EFFECTS.noise.type]: NoiseEffectIcon,\n  [POSTPROCESSING_EFFECTS.triangleBlur.type]: TriangleBlurEffectIcon,\n  [POSTPROCESSING_EFFECTS.zoomBlur.type]: ZoomBlurEffectIcon,\n  [POSTPROCESSING_EFFECTS.tiltShift.type]: TiltShiftEffectIcon,\n  [POSTPROCESSING_EFFECTS.edgeWork.type]: EdgeWorkEffectIcon,\n  [POSTPROCESSING_EFFECTS.vignette.type]: VignetteEffectIcon,\n  [POSTPROCESSING_EFFECTS.magnify.type]: MagnifyEffectIcon,\n  [POSTPROCESSING_EFFECTS.hexagonalPixelate.type]: HexagonalPixelateEffectIcon,\n  [DISTANCE_FOG_TYPE]: DistanceFogEffectIcon,\n  [SURFACE_FOG_TYPE]: SurfaceFogEffectIcon\n};\n\nconst StyledEffectPanelHeader = styled(StyledPanelHeader)`\n  height: ${props => props.theme.effectPanelHeaderHeight}px;\n  position: relative;\n  align-items: stretch;\n\n  .effect__drag-handle {\n    margin-left: -5px;\n    color: ${props => props.theme.textColor};\n  }\n\n  .effect__drag-handle__placeholder {\n    height: 20px;\n    padding: 0px;\n    margin: 10px 10px 10px 5px;\n  }\n\n  &:hover {\n    cursor: pointer;\n    background-color: ${props => props.theme.panelBackgroundHover};\n    .effect__drag-handle {\n      opacity: 1;\n    }\n  }\n\n  border-left: 3px solid ${props => props.theme.panelBackgroundHover};\n`;\n\nconst HeaderActionSection = styled.div`\n  display: flex;\n  position: absolute;\n  height: 100%;\n  align-items: stretch;\n  right: 10px;\n  &:hover {\n    .effect-panel__header__actions__hidden {\n      opacity: 1;\n      background-color: ${props => props.theme.panelBackgroundHover};\n    }\n  }\n`;\n\n// Hiden actions only show up on hover\ntype StyledPanelHeaderHiddenActionsProps = {$isConfigActive: boolean};\nconst StyledPanelHeaderHiddenActions = styled.div.attrs({\n  className: 'effect-panel__header__actions__hidden'\n})<StyledPanelHeaderHiddenActionsProps>`\n  opacity: 0;\n  display: flex;\n  align-items: center;\n  transition: opacity 0.4s ease, background-color 0.4s ease;\n  background-color: ${props =>\n    props.$isConfigActive ? props.theme.panelBackgroundHover : props.theme.panelBackground};\n\n  &:hover {\n    opacity: 1;\n  }\n`;\n\nconst StyledDragHandle = styled.div`\n  display: flex;\n  align-items: center;\n  opacity: 0;\n  z-index: 1000;\n  &:hover {\n    cursor: move;\n    opacity: 1;\n    color: ${props => props.theme.textColorHl};\n  }\n`;\n\nconst DragHandle = ({className, listeners, children}) => (\n  <StyledDragHandle className={className} {...listeners}>\n    {children}\n  </StyledDragHandle>\n);\n\nEffectPanelHeaderActionSectionFactory.deps = [PanelHeaderActionFactory];\n\nexport function EffectPanelHeaderActionSectionFactory(\n  PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>\n): React.FC<EffectPanelHeaderProps> {\n  const EffectPanelHeaderActionSection = (props: EffectPanelHeaderProps) => {\n    const {\n      effectId,\n      isEnabled,\n      isConfigActive,\n      onToggleEnabled,\n      onRemoveEffect,\n      onToggleEnableConfig,\n      actionItems,\n      actionIcons = defaultActionIcons\n    } = props;\n\n    const effectActionItems: ActionItem[] = useMemo(\n      () =>\n        actionItems ?? [\n          {\n            key: 'remove-effect',\n            isHidden: true,\n            tooltip: 'tooltip.removeEffect',\n            tooltipType: 'error',\n            onClick: onRemoveEffect,\n            icon: actionIcons.remove\n          },\n          {\n            key: 'visibility-toggle',\n            tooltip: isEnabled ? 'tooltip.disableEffect' : 'tooltip.enabledEffect',\n            onClick: onToggleEnabled,\n            icon: isEnabled ? actionIcons.visible : actionIcons.hidden\n          },\n          {\n            key: 'enable-config',\n            classNames: {'is-open': isConfigActive},\n            tooltip: 'tooltip.effectSettings',\n            onClick: onToggleEnableConfig,\n            icon: actionIcons.enableConfig\n          }\n        ],\n      [\n        actionItems,\n        actionIcons,\n        isEnabled,\n        isConfigActive,\n        onRemoveEffect,\n        onToggleEnabled,\n        onToggleEnableConfig\n      ]\n    );\n\n    return (\n      <HeaderActionSection className=\"effect-panel__header__actions\">\n        <StyledPanelHeaderHiddenActions $isConfigActive={isConfigActive}>\n          {effectActionItems\n            .filter((item: ActionItem) => Boolean(item.isHidden))\n            .map((item: ActionItem) => (\n              <PanelHeaderAction\n                key={item.key}\n                className={`effect__${item.key}`}\n                testId={`${item.key}-action`}\n                id={effectId}\n                tooltip={item.tooltip}\n                onClick={item.onClick}\n                tooltipType={item.tooltipType}\n                IconComponent={item.icon}\n              />\n            ))}\n        </StyledPanelHeaderHiddenActions>\n        {effectActionItems\n          .filter((item: ActionItem) => !item.isHidden)\n          .map((item: ActionItem) => (\n            <PanelHeaderAction\n              key={item.key}\n              className={classnames(`effect__${item.key}`, item.classNames)}\n              testId={`${item.key}-action`}\n              id={effectId}\n              tooltip={item.tooltip}\n              onClick={item.onClick}\n              tooltipType={item.tooltipType}\n              IconComponent={item.icon}\n            />\n          ))}\n      </HeaderActionSection>\n    );\n  };\n\n  return EffectPanelHeaderActionSection;\n}\n\nconst StyledEffectTitleSection = styled.div`\n  margin-left: 8px;\n  flex-grow: 1;\n  align-items: center;\n  display: flex;\n  color: ${props => props.theme.textColor};\n`;\n\nconst IconPlaceholder = styled.div`\n  width: 20px;\n  height: 20px;\n`;\n\nconst EffectIconWrapper = styled.div`\n  height: 18px;\n  margin: auto;\n  color: ${props => props.theme.textColor};\n`;\n\nEffectPanelHeaderFactory.deps = [EffectPanelHeaderActionSectionFactory];\n\nfunction EffectPanelHeaderFactory(\n  EffectPanelHeaderActionSection: ReturnType<typeof EffectPanelHeaderActionSectionFactory>\n): React.FC<EffectPanelHeaderProps> {\n  const EffectPanelHeader = (props: EffectPanelHeaderProps) => {\n    const {\n      isConfigActive,\n      isDragNDropEnabled = true,\n      type,\n      effectId,\n      onToggleEnableConfig,\n      listeners,\n      showSortHandle = true\n    } = props;\n\n    const intl = useIntl();\n\n    const effectDesc = useMemo(() => {\n      return EFFECT_DESCRIPTIONS.find(_description => _description.type === type);\n    }, [type]);\n\n    const label = effectDesc?.name || 'Effect';\n    const descriptionText = effectDesc?.description\n      ? intl.formatMessage({id: effectDesc.description, defaultMessage: ''})\n      : '';\n    const tooltipId = `effect-header-${effectId}`;\n\n    const EffectIcon = defaultEffectIcons[type];\n\n    return (\n      <StyledEffectPanelHeader\n        className={classnames('effect-panel__header', {\n          'sort--handle': !isConfigActive\n        })}\n        $active={isConfigActive}\n        onClick={onToggleEnableConfig}\n      >\n        {isDragNDropEnabled ? (\n          <DragHandle className=\"effect__drag-handle\" listeners={listeners}>\n            {showSortHandle ? <VertDots height=\"20px\" /> : <IconPlaceholder />}\n          </DragHandle>\n        ) : (\n          <div className=\"effect__drag-handle__placeholder\" />\n        )}\n\n        <EffectIconWrapper>{EffectIcon ? <EffectIcon height=\"18px\" /> : null}</EffectIconWrapper>\n\n        <StyledEffectTitleSection\n          data-tip={descriptionText || undefined}\n          data-for={descriptionText ? tooltipId : undefined}\n        >\n          {label}\n          {descriptionText ? (\n            <MultilineTooltip id={tooltipId} effect=\"solid\" place=\"bottom\" delayShow={500}>\n              {descriptionText}\n            </MultilineTooltip>\n          ) : null}\n        </StyledEffectTitleSection>\n\n        <EffectPanelHeaderActionSection {...props} />\n      </StyledEffectPanelHeader>\n    );\n  };\n\n  return EffectPanelHeader;\n}\n\nexport default EffectPanelHeaderFactory;\n"],"mappings":"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","ignoreList":[]}