@kepler.gl/components 3.3.0-alpha.1 → 3.3.0-alpha.10

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

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _useCloudListProvider = require("../hooks/use-cloud-list-provider");
+var _componentJestUtils = require("test/helpers/component-jest-utils");
+var _shareMapModal = _interopRequireDefault(require("./share-map-modal"));
+var _constants = require("@kepler.gl/constants");
+var _react2 = require("@testing-library/react");
+var _styledComponents = require("styled-components");
+var _reactIntl = require("react-intl");
+var _styles = require("@kepler.gl/styles");
+var _localization = require("@kepler.gl/localization");
+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) { (0, _defineProperty2["default"])(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
+jest.mock('../hooks/use-cloud-list-provider', function () {
+  return {
+    useCloudListProvider: jest.fn().mockImplementation(function () {
+      return {
+        provider: null,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    })
+  };
+});
+var ShareMapUrlModal = (0, _shareMapModal["default"])();
+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 = (0, _componentJestUtils.renderWithTheme)(/*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      getByText = _renderWithTheme.getByText,
+      queryByTestId = _renderWithTheme.queryByTestId;
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(queryByTestId(_constants.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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    var _renderWithTheme2 = (0, _componentJestUtils.renderWithTheme)(/*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      getByText = _renderWithTheme2.getByText,
+      getByTestId = _renderWithTheme2.getByTestId;
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(getByTestId(_constants.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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    var providerLoadingProps = _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+      isProviderLoading: true
+    });
+    var _renderWithTheme3 = (0, _componentJestUtils.renderWithTheme)(/*#__PURE__*/_react["default"].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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    (0, _componentJestUtils.renderWithTheme)(/*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS));
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  test('calls onExport after provider was updated', function () {
+    var _renderWithTheme4 = (0, _componentJestUtils.renderWithTheme)(/*#__PURE__*/_react["default"].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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    (0, _react2.act)(function () {
+      rerender(/*#__PURE__*/_react["default"].createElement(_styledComponents.ThemeProvider, {
+        theme: _styles.theme
+      }, /*#__PURE__*/_react["default"].createElement(_reactIntl.IntlProvider, {
+        locale: "en",
+        messages: _localization.messages
+      }, /*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS))));
+    });
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  it('displays share URL when provided', function () {
+    var shareUrl = 'http://example.com';
+    var _renderWithTheme5 = (0, _componentJestUtils.renderWithTheme)(/*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, (0, _extends2["default"])({}, DEFAULT_PROPS, {
+        successInfo: {
+          shareUrl: shareUrl
+        }
+      }))),
+      getByText = _renderWithTheme5.getByText;
+    expect(getByText('Share Url')).toBeInTheDocument();
+  });
+  it('renders errors', function () {
+    var _renderWithTheme6 = (0, _componentJestUtils.renderWithTheme)(/*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, (0, _extends2["default"])({}, 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","_interopRequireDefault","require","_useCloudListProvider","_componentJestUtils","_shareMapModal","_constants","_react2","_styledComponents","_reactIntl","_styles","_localization","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","useCloudListProvider","fn","mockImplementation","provider","setProvider","cloudProviders","ShareMapUrlModal","ShareMapUrlModalFactory","DEFAULT_PROPS","isProviderLoading","onExport","providerError","successInfo","undefined","onUpdateImageSetting","cleanupExportImage","describe","afterEach","clearAllMocks","test","_renderWithTheme","renderWithTheme","createElement","getByText","queryByTestId","expect","toBeInTheDocument","dataTestIds","providerShareMap","toBeNull","mapProvider","name","icon","getManagementUrl","listMaps","mockResolvedValue","hasSharingUrl","_renderWithTheme2","getByTestId","providerLoadingProps","_renderWithTheme3","toHaveBeenCalled","_renderWithTheme4","rerender","act","ThemeProvider","theme","IntlProvider","locale","messages","it","shareUrl","_renderWithTheme5","_extends2","_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/cjs/modals/status-panel.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.UploadAnimation = void 0;
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireDefault(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _icons = require("../common/icons");
+var _styledComponents2 = require("../common/styled-components");
+var _errorDisplay = _interopRequireDefault(require("./error-display"));
+var _localization = require("@kepler.gl/localization");
+var _templateObject, _templateObject2, _templateObject3; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var StyledUploader = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n"])));
+var StyledMapIcon = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  margin-right: 16px;\n  margin-top: 4px;\n"])), function (props) {
+  return props.theme.textColorLT;
+});
+var StyledSvg = _styledComponents["default"].svg(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\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["default"].createElement(StyledSvg, {
+    height: "5px",
+    width: "150px"
+  }, /*#__PURE__*/_react["default"].createElement("line", {
+    x1: "0",
+    y1: "4",
+    x2: "150",
+    y2: "4"
+  }));
+};
+var UploadAnimation = exports.UploadAnimation = function UploadAnimation(props) {
+  return /*#__PURE__*/_react["default"].createElement(StyledUploader, null, /*#__PURE__*/_react["default"].createElement(StyledMapIcon, null, /*#__PURE__*/_react["default"].createElement(_icons.MapIcon, {
+    height: "48px"
+  })), /*#__PURE__*/_react["default"].createElement(Line, null), props.icon && /*#__PURE__*/_react["default"].createElement(props.icon, {
+    height: "64px"
+  }));
+};
+var StatusPanel = function StatusPanel(_ref) {
+  var error = _ref.error,
+    isLoading = _ref.isLoading,
+    providerIcon = _ref.providerIcon;
+  return /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledExportSection, null, /*#__PURE__*/_react["default"].createElement("div", {
+    className: "description"
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    className: "title"
+  }, isLoading ? /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: 'modal.statusPanel.mapUploading'
+  }) : error ? /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: 'modal.statusPanel.error'
+  }) : null)), /*#__PURE__*/_react["default"].createElement("div", {
+    className: "selection"
+  }, isLoading && /*#__PURE__*/_react["default"].createElement(UploadAnimation, {
+    icon: providerIcon
+  }), error && /*#__PURE__*/_react["default"].createElement(_errorDisplay["default"], {
+    error: error
+  })));
+};
+var _default = exports["default"] = StatusPanel;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compositeSwipeFrame = compositeSwipeFrame;
+exports.getSwipePercentageAtTime = getSwipePercentageAtTime;
+var _popmotion = require("popmotion");
+var _deckglLayers = require("@kepler.gl/deckgl-layers");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var linear = function linear(p) {
+  return p;
+};
+var EASING_MAP = {
+  linear: linear,
+  'ease-in-out': _popmotion.easeInOut
+};
+
+/**
+ * Compute the swipe percentage at a given time.
+ */
+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.
+ */
+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) {
+    (0, _deckglLayers.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":["_popmotion","require","_deckglLayers","linear","p","EASING_MAP","easeInOut","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","drawStarsBackground","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/cjs/modals/swipe-composite-utils.spec.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _deckglLayers = require("@kepler.gl/deckgl-layers");
+var _swipeCompositeUtils = require("./swipe-composite-utils");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+jest.mock('@kepler.gl/deckgl-layers', function () {
+  return {
+    drawStarsBackground: jest.fn()
+  };
+});
+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);
+    (0, _swipeCompositeUtils.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(_deckglLayers.drawStarsBackground).toHaveBeenCalledWith(ctx, 100, 50);
+    expect(ctx.fillRect.mock.invocationCallOrder[0]).toBeLessThan(_deckglLayers.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);
+    (0, _swipeCompositeUtils.compositeSwipeFrame)(left, right, output, 50, false, 'rgb(1, 2, 3)');
+    expect(_deckglLayers.drawStarsBackground).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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