@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/esm/modals/share-map-modal.spec.js

@@ -0,0 +1,172 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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
+
+// @ts-nocheck
+import React from 'react';
+import { useCloudListProvider } from '../hooks/use-cloud-list-provider';
+import { renderWithTheme } from 'test/helpers/component-jest-utils';
+import ShareMapUrlModalFactory from './share-map-modal';
+import { dataTestIds } from '@kepler.gl/constants';
+import { act } from '@testing-library/react';
+import { ThemeProvider } from 'styled-components';
+import { IntlProvider } from 'react-intl';
+import { theme } from '@kepler.gl/styles';
+import { messages } from '@kepler.gl/localization';
+jest.mock('../hooks/use-cloud-list-provider', function () {
+  return {
+    useCloudListProvider: jest.fn().mockImplementation(function () {
+      return {
+        provider: null,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    })
+  };
+});
+var ShareMapUrlModal = ShareMapUrlModalFactory();
+var DEFAULT_PROPS = {
+  isProviderLoading: false,
+  onExport: jest.fn(),
+  providerError: null,
+  successInfo: undefined,
+  onUpdateImageSetting: jest.fn(),
+  cleanupExportImage: jest.fn()
+};
+describe('ShareMapModal', function () {
+  afterEach(function () {
+    jest.clearAllMocks();
+  });
+  test('renders only list of providers', function () {
+    var _renderWithTheme = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      getByText = _renderWithTheme.getByText,
+      queryByTestId = _renderWithTheme.queryByTestId;
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(queryByTestId(dataTestIds.providerShareMap)).toBeNull();
+  });
+  test('renders list of provider and sharing section', function () {
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    var _renderWithTheme2 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      getByText = _renderWithTheme2.getByText,
+      getByTestId = _renderWithTheme2.getByTestId;
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(getByTestId(dataTestIds.providerShareMap)).toBeInTheDocument();
+  });
+  test('renders loading when isLoading is set to true', function () {
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    var providerLoadingProps = _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+      isProviderLoading: true
+    });
+    var _renderWithTheme3 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, providerLoadingProps)),
+      getByText = _renderWithTheme3.getByText;
+    expect(getByText('modal.statusPanel.mapUploading')).toBeInTheDocument();
+  });
+  test('calls onExport when provider is set correctly', function () {
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS));
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  test('calls onExport after provider was updated', function () {
+    var _renderWithTheme4 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      rerender = _renderWithTheme4.rerender;
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    act(function () {
+      rerender(/*#__PURE__*/React.createElement(ThemeProvider, {
+        theme: theme
+      }, /*#__PURE__*/React.createElement(IntlProvider, {
+        locale: "en",
+        messages: messages
+      }, /*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS))));
+    });
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  it('displays share URL when provided', function () {
+    var shareUrl = 'http://example.com';
+    var _renderWithTheme5 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, _extends({}, DEFAULT_PROPS, {
+        successInfo: {
+          shareUrl: shareUrl
+        }
+      }))),
+      getByText = _renderWithTheme5.getByText;
+    expect(getByText('Share Url')).toBeInTheDocument();
+  });
+  it('renders errors', function () {
+    var _renderWithTheme6 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, _extends({}, DEFAULT_PROPS, {
+        providerError: new Error('timeout')
+      }))),
+      getByText = _renderWithTheme6.getByText;
+    expect(getByText('modal.statusPanel.error')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCloudListProvider","renderWithTheme","ShareMapUrlModalFactory","dataTestIds","act","ThemeProvider","IntlProvider","theme","messages","jest","mock","fn","mockImplementation","provider","setProvider","cloudProviders","ShareMapUrlModal","DEFAULT_PROPS","isProviderLoading","onExport","providerError","successInfo","undefined","onUpdateImageSetting","cleanupExportImage","describe","afterEach","clearAllMocks","test","_renderWithTheme","createElement","getByText","queryByTestId","expect","toBeInTheDocument","providerShareMap","toBeNull","mapProvider","name","icon","getManagementUrl","listMaps","mockResolvedValue","hasSharingUrl","_renderWithTheme2","getByTestId","providerLoadingProps","_objectSpread","_renderWithTheme3","toHaveBeenCalled","_renderWithTheme4","rerender","locale","it","shareUrl","_renderWithTheme5","_extends","_renderWithTheme6","Error"],"sources":["../../../src/modals/share-map-modal.spec.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// @ts-nocheck\nimport React from 'react';\nimport {useCloudListProvider} from '../hooks/use-cloud-list-provider';\nimport {renderWithTheme} from 'test/helpers/component-jest-utils';\nimport ShareMapUrlModalFactory from './share-map-modal';\nimport {dataTestIds} from '@kepler.gl/constants';\nimport {act} from '@testing-library/react';\nimport {ThemeProvider} from 'styled-components';\nimport {IntlProvider} from 'react-intl';\nimport {theme} from '@kepler.gl/styles';\nimport {messages} from '@kepler.gl/localization';\n\njest.mock('../hooks/use-cloud-list-provider', () => ({\n  useCloudListProvider: jest.fn().mockImplementation(() => ({\n    provider: null,\n    setProvider: jest.fn(),\n    cloudProviders: []\n  }))\n}));\n\nconst ShareMapUrlModal = ShareMapUrlModalFactory();\n\nconst DEFAULT_PROPS = {\n  isProviderLoading: false,\n  onExport: jest.fn(),\n  providerError: null,\n  successInfo: undefined,\n  onUpdateImageSetting: jest.fn(),\n  cleanupExportImage: jest.fn()\n};\n\ndescribe('ShareMapModal', () => {\n  afterEach(() => {\n    jest.clearAllMocks();\n  });\n\n  test('renders only list of providers', () => {\n    const {getByText, queryByTestId} = renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n    expect(getByText('modal.shareMap.title')).toBeInTheDocument();\n    expect(queryByTestId(dataTestIds.providerShareMap)).toBeNull();\n  });\n\n  test('renders list of provider and sharing section', () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const {getByText, getByTestId} = renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n    expect(getByText('modal.shareMap.title')).toBeInTheDocument();\n    expect(getByTestId(dataTestIds.providerShareMap)).toBeInTheDocument();\n  });\n\n  test('renders loading when isLoading is set to true', () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const providerLoadingProps = {\n      ...DEFAULT_PROPS,\n      isProviderLoading: true\n    };\n\n    const {getByText} = renderWithTheme(<ShareMapUrlModal {...providerLoadingProps} />);\n    expect(getByText('modal.statusPanel.mapUploading')).toBeInTheDocument();\n  });\n\n  test('calls onExport when provider is set correctly', () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n\n    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();\n  });\n\n  test('calls onExport after provider was updated', () => {\n    const {rerender} = renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    act(() => {\n      rerender(\n        <ThemeProvider theme={theme}>\n          <IntlProvider locale=\"en\" messages={messages}>\n            <ShareMapUrlModal {...DEFAULT_PROPS} />\n          </IntlProvider>\n        </ThemeProvider>\n      );\n    });\n\n    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();\n  });\n\n  it('displays share URL when provided', () => {\n    const shareUrl = 'http://example.com';\n    const {getByText} = renderWithTheme(\n      <ShareMapUrlModal {...DEFAULT_PROPS} successInfo={{shareUrl}} />\n    );\n    expect(getByText('Share Url')).toBeInTheDocument();\n  });\n\n  it('renders errors', () => {\n    const {getByText} = renderWithTheme(\n      <ShareMapUrlModal {...DEFAULT_PROPS} providerError={new Error('timeout')} />\n    );\n    expect(getByText('modal.statusPanel.error')).toBeInTheDocument();\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/modals/status-panel.js

@@ -0,0 +1,60 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { MapIcon } from '../common/icons';
+import { StyledExportSection } from '../common/styled-components';
+import ErrorDisplay from './error-display';
+import { FormattedMessage } from '@kepler.gl/localization';
+var StyledUploader = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n"])));
+var StyledMapIcon = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  color: ", ";\n  margin-right: 16px;\n  margin-top: 4px;\n"])), function (props) {
+  return props.theme.textColorLT;
+});
+var StyledSvg = styled.svg(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  margin-right: 16px;\n\n  line {\n    stroke: ", ";\n    stroke-width: 4;\n    stroke-linecap: square;\n    stroke-dasharray: 5 12;\n    animation: dash-animation 25s infinite linear;\n  }\n  circle {\n    fill: ", ";\n  }\n\n  @keyframes dash-animation {\n    to {\n      stroke-dashoffset: -1000;\n    }\n  }\n"])), function (props) {
+  return props.theme.selectBorderColorLT;
+}, function (props) {
+  return props.theme.selectBorderColorLT;
+});
+var Line = function Line() {
+  return /*#__PURE__*/React.createElement(StyledSvg, {
+    height: "5px",
+    width: "150px"
+  }, /*#__PURE__*/React.createElement("line", {
+    x1: "0",
+    y1: "4",
+    x2: "150",
+    y2: "4"
+  }));
+};
+export var UploadAnimation = function UploadAnimation(props) {
+  return /*#__PURE__*/React.createElement(StyledUploader, null, /*#__PURE__*/React.createElement(StyledMapIcon, null, /*#__PURE__*/React.createElement(MapIcon, {
+    height: "48px"
+  })), /*#__PURE__*/React.createElement(Line, null), props.icon && /*#__PURE__*/React.createElement(props.icon, {
+    height: "64px"
+  }));
+};
+var StatusPanel = function StatusPanel(_ref) {
+  var error = _ref.error,
+    isLoading = _ref.isLoading,
+    providerIcon = _ref.providerIcon;
+  return /*#__PURE__*/React.createElement(StyledExportSection, null, /*#__PURE__*/React.createElement("div", {
+    className: "description"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "title"
+  }, isLoading ? /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: 'modal.statusPanel.mapUploading'
+  }) : error ? /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: 'modal.statusPanel.error'
+  }) : null)), /*#__PURE__*/React.createElement("div", {
+    className: "selection"
+  }, isLoading && /*#__PURE__*/React.createElement(UploadAnimation, {
+    icon: providerIcon
+  }), error && /*#__PURE__*/React.createElement(ErrorDisplay, {
+    error: error
+  })));
+};
+export default StatusPanel;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/swipe-composite-utils.js

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { easeInOut } from 'popmotion';
+import { drawStarsBackground } from '@kepler.gl/deckgl-layers';
+var linear = function linear(p) {
+  return p;
+};
+var EASING_MAP = {
+  linear: linear,
+  'ease-in-out': easeInOut
+};
+
+/**
+ * Compute the swipe percentage at a given time.
+ */
+export function getSwipePercentageAtTime(timeMs, durationMs, startPct, endPct) {
+  var easing = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'ease-in-out';
+  var progress = Math.max(0, Math.min(1, timeMs / durationMs));
+  var easedProgress = EASING_MAP[easing](progress);
+  return startPct + (endPct - startPct) * easedProgress;
+}
+var HANDLE_RADIUS = 14;
+var ARROW_SIZE = 6;
+
+/**
+ * Draw a swipe divider (line + circular handle with arrows) onto a 2D canvas context.
+ */
+function drawSwipeDivider(ctx, splitX, height) {
+  ctx.save();
+
+  // Divider line
+  ctx.strokeStyle = '#FFFFFF';
+  ctx.lineWidth = 2;
+  ctx.shadowColor = 'rgba(0, 0, 0, 0.5)';
+  ctx.shadowBlur = 4;
+  ctx.beginPath();
+  ctx.moveTo(splitX, 0);
+  ctx.lineTo(splitX, height);
+  ctx.stroke();
+
+  // Handle circle
+  var cy = height / 2;
+  ctx.shadowBlur = 6;
+  ctx.beginPath();
+  ctx.arc(splitX, cy, HANDLE_RADIUS, 0, Math.PI * 2);
+  ctx.fillStyle = '#29323C';
+  ctx.fill();
+  ctx.strokeStyle = '#FFFFFF';
+  ctx.lineWidth = 2;
+  ctx.stroke();
+  ctx.shadowBlur = 0;
+
+  // Left arrow
+  ctx.fillStyle = '#FFFFFF';
+  ctx.beginPath();
+  ctx.moveTo(splitX - ARROW_SIZE - 3, cy);
+  ctx.lineTo(splitX - 3, cy - ARROW_SIZE);
+  ctx.lineTo(splitX - 3, cy + ARROW_SIZE);
+  ctx.closePath();
+  ctx.fill();
+
+  // Right arrow
+  ctx.beginPath();
+  ctx.moveTo(splitX + ARROW_SIZE + 3, cy);
+  ctx.lineTo(splitX + 3, cy - ARROW_SIZE);
+  ctx.lineTo(splitX + 3, cy + ARROW_SIZE);
+  ctx.closePath();
+  ctx.fill();
+  ctx.restore();
+}
+
+/**
+ * Composite two canvases (left/right map views) with a swipe divider
+ * into a single output canvas.
+ */
+export function compositeSwipeFrame(leftCanvas, rightCanvas, outputCanvas, percentage) {
+  var showDivider = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  var backgroundColor = arguments.length > 5 ? arguments[5] : undefined;
+  var showStars = arguments.length > 6 ? arguments[6] : undefined;
+  var ctx = outputCanvas.getContext('2d');
+  if (!ctx) return;
+  var w = outputCanvas.width;
+  var h = outputCanvas.height;
+  var splitX = Math.round(w * percentage / 100);
+  ctx.clearRect(0, 0, w, h);
+
+  // In globe mode the deck canvases are transparent where the globe isn't
+  // drawn (clearColor is disabled to keep picking intact), so paint the
+  // configured background first. Non-globe swipe passes no color and keeps the
+  // previous transparent-clear behavior (the base map is already opaque).
+  if (backgroundColor) {
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, w, h);
+  }
+
+  // Stars are a CSS background on the live globe map, so they must be tiled
+  // onto the composite canvas or they won't appear in preview or export.
+  if (showStars) {
+    drawStarsBackground(ctx, w, h);
+  }
+
+  // Draw right (background) canvas fully
+  ctx.drawImage(rightCanvas, 0, 0, w, h);
+
+  // Draw left (foreground) canvas clipped to 0..splitX
+  ctx.save();
+  ctx.beginPath();
+  ctx.rect(0, 0, splitX, h);
+  ctx.clip();
+  ctx.drawImage(leftCanvas, 0, 0, w, h);
+  ctx.restore();
+
+  // Draw the divider
+  if (showDivider) {
+    drawSwipeDivider(ctx, splitX, h);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["easeInOut","drawStarsBackground","linear","p","EASING_MAP","getSwipePercentageAtTime","timeMs","durationMs","startPct","endPct","easing","arguments","length","undefined","progress","Math","max","min","easedProgress","HANDLE_RADIUS","ARROW_SIZE","drawSwipeDivider","ctx","splitX","height","save","strokeStyle","lineWidth","shadowColor","shadowBlur","beginPath","moveTo","lineTo","stroke","cy","arc","PI","fillStyle","fill","closePath","restore","compositeSwipeFrame","leftCanvas","rightCanvas","outputCanvas","percentage","showDivider","backgroundColor","showStars","getContext","w","width","h","round","clearRect","fillRect","drawImage","rect","clip"],"sources":["../../../src/modals/swipe-composite-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {easeInOut} from 'popmotion';\nimport {drawStarsBackground} from '@kepler.gl/deckgl-layers';\n\nexport type SwipeEasing = 'linear' | 'ease-in-out';\n\nconst linear = (p: number): number => p;\nconst EASING_MAP: Record<SwipeEasing, (p: number) => number> = {\n  linear,\n  'ease-in-out': easeInOut\n};\n\n/**\n * Compute the swipe percentage at a given time.\n */\nexport function getSwipePercentageAtTime(\n  timeMs: number,\n  durationMs: number,\n  startPct: number,\n  endPct: number,\n  easing: SwipeEasing = 'ease-in-out'\n): number {\n  const progress = Math.max(0, Math.min(1, timeMs / durationMs));\n  const easedProgress = EASING_MAP[easing](progress);\n  return startPct + (endPct - startPct) * easedProgress;\n}\n\nconst HANDLE_RADIUS = 14;\nconst ARROW_SIZE = 6;\n\n/**\n * Draw a swipe divider (line + circular handle with arrows) onto a 2D canvas context.\n */\nfunction drawSwipeDivider(\n  ctx: CanvasRenderingContext2D,\n  splitX: number,\n  height: number\n): void {\n  ctx.save();\n\n  // Divider line\n  ctx.strokeStyle = '#FFFFFF';\n  ctx.lineWidth = 2;\n  ctx.shadowColor = 'rgba(0, 0, 0, 0.5)';\n  ctx.shadowBlur = 4;\n  ctx.beginPath();\n  ctx.moveTo(splitX, 0);\n  ctx.lineTo(splitX, height);\n  ctx.stroke();\n\n  // Handle circle\n  const cy = height / 2;\n  ctx.shadowBlur = 6;\n  ctx.beginPath();\n  ctx.arc(splitX, cy, HANDLE_RADIUS, 0, Math.PI * 2);\n  ctx.fillStyle = '#29323C';\n  ctx.fill();\n  ctx.strokeStyle = '#FFFFFF';\n  ctx.lineWidth = 2;\n  ctx.stroke();\n  ctx.shadowBlur = 0;\n\n  // Left arrow\n  ctx.fillStyle = '#FFFFFF';\n  ctx.beginPath();\n  ctx.moveTo(splitX - ARROW_SIZE - 3, cy);\n  ctx.lineTo(splitX - 3, cy - ARROW_SIZE);\n  ctx.lineTo(splitX - 3, cy + ARROW_SIZE);\n  ctx.closePath();\n  ctx.fill();\n\n  // Right arrow\n  ctx.beginPath();\n  ctx.moveTo(splitX + ARROW_SIZE + 3, cy);\n  ctx.lineTo(splitX + 3, cy - ARROW_SIZE);\n  ctx.lineTo(splitX + 3, cy + ARROW_SIZE);\n  ctx.closePath();\n  ctx.fill();\n\n  ctx.restore();\n}\n\n/**\n * Composite two canvases (left/right map views) with a swipe divider\n * into a single output canvas.\n */\nexport function compositeSwipeFrame(\n  leftCanvas: HTMLCanvasElement,\n  rightCanvas: HTMLCanvasElement,\n  outputCanvas: HTMLCanvasElement,\n  percentage: number,\n  showDivider: boolean = true,\n  backgroundColor?: string,\n  showStars?: boolean\n): void {\n  const ctx = outputCanvas.getContext('2d');\n  if (!ctx) return;\n\n  const w = outputCanvas.width;\n  const h = outputCanvas.height;\n  const splitX = Math.round((w * percentage) / 100);\n\n  ctx.clearRect(0, 0, w, h);\n\n  // In globe mode the deck canvases are transparent where the globe isn't\n  // drawn (clearColor is disabled to keep picking intact), so paint the\n  // configured background first. Non-globe swipe passes no color and keeps the\n  // previous transparent-clear behavior (the base map is already opaque).\n  if (backgroundColor) {\n    ctx.fillStyle = backgroundColor;\n    ctx.fillRect(0, 0, w, h);\n  }\n\n  // Stars are a CSS background on the live globe map, so they must be tiled\n  // onto the composite canvas or they won't appear in preview or export.\n  if (showStars) {\n    drawStarsBackground(ctx, w, h);\n  }\n\n  // Draw right (background) canvas fully\n  ctx.drawImage(rightCanvas, 0, 0, w, h);\n\n  // Draw left (foreground) canvas clipped to 0..splitX\n  ctx.save();\n  ctx.beginPath();\n  ctx.rect(0, 0, splitX, h);\n  ctx.clip();\n  ctx.drawImage(leftCanvas, 0, 0, w, h);\n  ctx.restore();\n\n  // Draw the divider\n  if (showDivider) {\n    drawSwipeDivider(ctx, splitX, h);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/modals/swipe-composite-utils.spec.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+jest.mock('@kepler.gl/deckgl-layers', function () {
+  return {
+    drawStarsBackground: jest.fn()
+  };
+});
+import { drawStarsBackground } from '@kepler.gl/deckgl-layers';
+import { compositeSwipeFrame } from './swipe-composite-utils';
+function mockCanvas(width, height, ctx) {
+  return {
+    width: width,
+    height: height,
+    getContext: function getContext() {
+      return ctx;
+    }
+  };
+}
+function mockCompositeCtx() {
+  return {
+    clearRect: jest.fn(),
+    fillRect: jest.fn(),
+    drawImage: jest.fn(),
+    save: jest.fn(),
+    restore: jest.fn(),
+    beginPath: jest.fn(),
+    rect: jest.fn(),
+    clip: jest.fn(),
+    fillStyle: '',
+    strokeStyle: '',
+    lineWidth: 0,
+    shadowColor: '',
+    shadowBlur: 0,
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    stroke: jest.fn(),
+    arc: jest.fn(),
+    fill: jest.fn(),
+    closePath: jest.fn()
+  };
+}
+describe('compositeSwipeFrame', function () {
+  afterEach(function () {
+    jest.clearAllMocks();
+  });
+  test('tiles stars after the globe background color when showStars is true', function () {
+    var ctx = mockCompositeCtx();
+    var left = mockCanvas(10, 10, ctx);
+    var right = mockCanvas(10, 10, ctx);
+    var output = mockCanvas(100, 50, ctx);
+    compositeSwipeFrame(left, right, output, 50, false, 'rgb(1, 2, 3)', true);
+    expect(ctx.fillStyle).toBe('rgb(1, 2, 3)');
+    expect(ctx.fillRect).toHaveBeenCalledWith(0, 0, 100, 50);
+    expect(drawStarsBackground).toHaveBeenCalledWith(ctx, 100, 50);
+    expect(ctx.fillRect.mock.invocationCallOrder[0]).toBeLessThan(drawStarsBackground.mock.invocationCallOrder[0]);
+  });
+  test('does not draw stars when showStars is omitted', function () {
+    var ctx = mockCompositeCtx();
+    var left = mockCanvas(10, 10, ctx);
+    var right = mockCanvas(10, 10, ctx);
+    var output = mockCanvas(100, 50, ctx);
+    compositeSwipeFrame(left, right, output, 50, false, 'rgb(1, 2, 3)');
+    expect(drawStarsBackground).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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