@kepler.gl/deckgl-layers 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/cjs/globe/globe-stars-layer.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.drawStarsBackground = drawStarsBackground;
+exports.getStarsBackgroundImage = getStarsBackgroundImage;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Generates a tileable star-field used behind the globe.
+ * The live map and video-export preview paint it as a CSS `background-image`
+ * with `background-repeat: repeat`. Video-export capture (which only reads
+ * canvas pixels) tiles the same image onto a 2D context via
+ * `drawStarsBackground`. The result is deterministic (seeded PRNG) and cached
+ * so it's only generated once.
+ */
+
+var STAR_CANVAS_SIZE = 512;
+var STAR_COUNT = 600;
+
+// Seeded pseudo-random number generator (Park-Miller) for determinism.
+function seededRandom(seed) {
+  var s = seed;
+  return function () {
+    s = s * 16807 % 2147483647;
+    return (s - 1) / 2147483646;
+  };
+}
+
+// Transparent 1x1 PNG used as a fallback when a canvas context is unavailable
+// (SSR or unsupported browser), so that `url(...)` never resolves to an empty
+// value that could trigger a request for the current document.
+var TRANSPARENT_PIXEL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
+var cachedCanvas = null;
+var cachedDataUrl = null;
+function generateStarsTile() {
+  if (typeof document === 'undefined') {
+    return null;
+  }
+  var canvas = document.createElement('canvas');
+  canvas.width = STAR_CANVAS_SIZE;
+  canvas.height = STAR_CANVAS_SIZE;
+  var ctx = canvas.getContext('2d');
+  if (!ctx) return null;
+
+  // Transparent background so CSS backgroundColor / canvas fill shows through
+  ctx.clearRect(0, 0, STAR_CANVAS_SIZE, STAR_CANVAS_SIZE);
+  var random = seededRandom(42);
+  for (var i = 0; i < STAR_COUNT; i++) {
+    var x = random() * STAR_CANVAS_SIZE;
+    var y = random() * STAR_CANVAS_SIZE;
+    var brightness = 140 + Math.floor(random() * 115); // 140–255
+    var alpha = 0.4 + random() * 0.6; // 0.4–1.0
+    var radius = 0.3 + random() * 1.0; // 0.3–1.3 px
+
+    ctx.beginPath();
+    ctx.arc(x, y, radius, 0, Math.PI * 2);
+    ctx.fillStyle = "rgba(".concat(brightness, ", ").concat(brightness, ", ").concat(brightness, ", ").concat(alpha, ")");
+    ctx.fill();
+  }
+  return canvas;
+}
+function getStarsTileCanvas() {
+  if (cachedCanvas) return cachedCanvas;
+  cachedCanvas = generateStarsTile();
+  return cachedCanvas;
+}
+
+/**
+ * Returns a data URL of a tileable star-field image (512×512 PNG).
+ * Generates the image once and caches it for subsequent calls.
+ */
+function getStarsBackgroundImage() {
+  if (cachedDataUrl) return cachedDataUrl;
+  var canvas = getStarsTileCanvas();
+  if (!canvas) {
+    // SSR / missing 2D context: return a transparent 1x1 pixel so url() never
+    // resolves to an empty value that could trigger a request for the document.
+    return cachedDataUrl = TRANSPARENT_PIXEL;
+  }
+  cachedDataUrl = canvas.toDataURL('image/png');
+  return cachedDataUrl;
+}
+
+/**
+ * Tile the star-field onto a 2D canvas (e.g. video-export frame capture).
+ * Stars are drawn with alpha so the caller should fill the background color first.
+ */
+function drawStarsBackground(ctx, width, height) {
+  var tile = getStarsTileCanvas();
+  if (!tile || width <= 0 || height <= 0) return;
+  var pattern = ctx.createPattern(tile, 'repeat');
+  if (!pattern) return;
+  ctx.fillStyle = pattern;
+  ctx.fillRect(0, 0, width, height);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["STAR_CANVAS_SIZE","STAR_COUNT","seededRandom","seed","s","TRANSPARENT_PIXEL","cachedCanvas","cachedDataUrl","generateStarsTile","document","canvas","createElement","width","height","ctx","getContext","clearRect","random","i","x","y","brightness","Math","floor","alpha","radius","beginPath","arc","PI","fillStyle","concat","fill","getStarsTileCanvas","getStarsBackgroundImage","toDataURL","drawStarsBackground","tile","pattern","createPattern","fillRect"],"sources":["../../../src/globe/globe-stars-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Generates a tileable star-field used behind the globe.\n * The live map and video-export preview paint it as a CSS `background-image`\n * with `background-repeat: repeat`. Video-export capture (which only reads\n * canvas pixels) tiles the same image onto a 2D context via\n * `drawStarsBackground`. The result is deterministic (seeded PRNG) and cached\n * so it's only generated once.\n */\n\nconst STAR_CANVAS_SIZE = 512;\nconst STAR_COUNT = 600;\n\n// Seeded pseudo-random number generator (Park-Miller) for determinism.\nfunction seededRandom(seed: number): () => number {\n  let s = seed;\n  return () => {\n    s = (s * 16807) % 2147483647;\n    return (s - 1) / 2147483646;\n  };\n}\n\n// Transparent 1x1 PNG used as a fallback when a canvas context is unavailable\n// (SSR or unsupported browser), so that `url(...)` never resolves to an empty\n// value that could trigger a request for the current document.\nconst TRANSPARENT_PIXEL =\n  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';\n\nlet cachedCanvas: HTMLCanvasElement | null = null;\nlet cachedDataUrl: string | null = null;\n\nfunction generateStarsTile(): HTMLCanvasElement | null {\n  if (typeof document === 'undefined') {\n    return null;\n  }\n\n  const canvas = document.createElement('canvas');\n  canvas.width = STAR_CANVAS_SIZE;\n  canvas.height = STAR_CANVAS_SIZE;\n  const ctx = canvas.getContext('2d');\n  if (!ctx) return null;\n\n  // Transparent background so CSS backgroundColor / canvas fill shows through\n  ctx.clearRect(0, 0, STAR_CANVAS_SIZE, STAR_CANVAS_SIZE);\n\n  const random = seededRandom(42);\n\n  for (let i = 0; i < STAR_COUNT; i++) {\n    const x = random() * STAR_CANVAS_SIZE;\n    const y = random() * STAR_CANVAS_SIZE;\n    const brightness = 140 + Math.floor(random() * 115); // 140–255\n    const alpha = 0.4 + random() * 0.6; // 0.4–1.0\n    const radius = 0.3 + random() * 1.0; // 0.3–1.3 px\n\n    ctx.beginPath();\n    ctx.arc(x, y, radius, 0, Math.PI * 2);\n    ctx.fillStyle = `rgba(${brightness}, ${brightness}, ${brightness}, ${alpha})`;\n    ctx.fill();\n  }\n\n  return canvas;\n}\n\nfunction getStarsTileCanvas(): HTMLCanvasElement | null {\n  if (cachedCanvas) return cachedCanvas;\n  cachedCanvas = generateStarsTile();\n  return cachedCanvas;\n}\n\n/**\n * Returns a data URL of a tileable star-field image (512×512 PNG).\n * Generates the image once and caches it for subsequent calls.\n */\nexport function getStarsBackgroundImage(): string {\n  if (cachedDataUrl) return cachedDataUrl;\n\n  const canvas = getStarsTileCanvas();\n  if (!canvas) {\n    // SSR / missing 2D context: return a transparent 1x1 pixel so url() never\n    // resolves to an empty value that could trigger a request for the document.\n    return (cachedDataUrl = TRANSPARENT_PIXEL);\n  }\n\n  cachedDataUrl = canvas.toDataURL('image/png');\n  return cachedDataUrl;\n}\n\n/**\n * Tile the star-field onto a 2D canvas (e.g. video-export frame capture).\n * Stars are drawn with alpha so the caller should fill the background color first.\n */\nexport function drawStarsBackground(\n  ctx: CanvasRenderingContext2D,\n  width: number,\n  height: number\n): void {\n  const tile = getStarsTileCanvas();\n  if (!tile || width <= 0 || height <= 0) return;\n  const pattern = ctx.createPattern(tile, 'repeat');\n  if (!pattern) return;\n  ctx.fillStyle = pattern;\n  ctx.fillRect(0, 0, width, height);\n}\n\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/globe/globe-stars-layer.spec.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _globeStarsLayer = require("./globe-stars-layer");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+describe('globe-stars-layer', function () {
+  afterEach(function () {
+    jest.restoreAllMocks();
+  });
+  test('drawStarsBackground tiles the star canvas with a repeating pattern', function () {
+    var tileCtx = {
+      clearRect: jest.fn(),
+      beginPath: jest.fn(),
+      arc: jest.fn(),
+      fill: jest.fn(),
+      fillStyle: ''
+    };
+    var originalGetContext = HTMLCanvasElement.prototype.getContext;
+    jest.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function getContext(type) {
+      if (type === '2d') {
+        return tileCtx;
+      }
+      return originalGetContext.call(this, type);
+    });
+    var pattern = {
+      id: 'stars-pattern'
+    };
+    var destCtx = {
+      createPattern: jest.fn(function () {
+        return pattern;
+      }),
+      fillRect: jest.fn(),
+      fillStyle: ''
+    };
+    (0, _globeStarsLayer.drawStarsBackground)(destCtx, 1280, 720);
+    expect(destCtx.createPattern).toHaveBeenCalledWith(expect.any(HTMLCanvasElement), 'repeat');
+    expect(destCtx.fillStyle).toBe(pattern);
+    expect(destCtx.fillRect).toHaveBeenCalledWith(0, 0, 1280, 720);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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