@deck.gl-community/layers 9.0.0-alpha.1 → 9.0.2

package/dist/index.cjs

@@ -0,0 +1,605 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  PathMarkerLayer: () => PathMarkerLayer,
+  PathOutlineLayer: () => PathOutlineLayer,
+  TileSourceLayer: () => TileSourceLayer
+});
+module.exports = __toCommonJS(dist_exports);
+
+// dist/tile-source-layer/tile-source-layer.js
+var import_core = require("@deck.gl/core");
+var import_geo_layers = require("@deck.gl/geo-layers");
+var import_layers = require("@deck.gl/layers");
+var devicePixelRatio = typeof window !== "undefined" && window.devicePixelRatio || 1;
+var TileSourceLayer = class extends import_core.CompositeLayer {
+  state = void 0;
+  initializeState() {
+    this.setState({
+      tileSource: null
+    });
+  }
+  updateState({ props, changeFlags }) {
+    this.setState({
+      tileSource: props.tileSource
+    });
+  }
+  renderLayers() {
+    const { tileSource, showTileBorders, metadata, onTilesLoad } = this.props;
+    const minZoom = (metadata == null ? void 0 : metadata.minZoom) || 0;
+    const maxZoom = (metadata == null ? void 0 : metadata.maxZoom) || 30;
+    return [
+      new import_geo_layers.TileLayer({
+        // HACK: Trigger new layer via id prop to force clear tile cache
+        id: String(tileSource.url),
+        getTileData: tileSource.getTileData,
+        // Assume the pmtiles file support HTTP/2, so we aren't limited by the browser to a certain number per domain.
+        maxRequests: 20,
+        pickable: true,
+        onViewportLoad: onTilesLoad,
+        autoHighlight: showTileBorders,
+        highlightColor: [60, 60, 60, 40],
+        minZoom,
+        maxZoom,
+        tileSize: 256,
+        // TOOD - why is this needed?
+        zoomOffset: devicePixelRatio === 1 ? -1 : 0,
+        renderSubLayers,
+        // Custom prop
+        tileSource,
+        showTileBorders
+      })
+    ];
+  }
+};
+__publicField(TileSourceLayer, "layerName", "TileSourceLayer");
+__publicField(TileSourceLayer, "defaultProps", {
+  ...import_geo_layers.TileLayer.defaultProps,
+  showTileBorders: true
+});
+function renderSubLayers(props) {
+  const { tileSource, showTileBorders, minZoom, maxZoom, tile: { index: { z: zoom }, bbox: { west, south, east, north } } } = props;
+  const layers = [];
+  const borderColor = zoom <= minZoom || zoom >= maxZoom ? [255, 0, 0, 255] : [0, 0, 255, 255];
+  switch (tileSource.mimeType) {
+    case "application/vnd.mapbox-vector-tile":
+      layers.push(new import_layers.GeoJsonLayer({
+        id: `${props.id}-geojson`,
+        data: props.data,
+        pickable: true,
+        getFillColor: [0, 190, 80, 255],
+        lineWidthScale: 500,
+        lineWidthMinPixels: 0.5
+      }));
+      break;
+    case "image/png":
+    case "image/jpeg":
+    case "image/webp":
+    case "image/avif":
+      layers.push(new import_layers.BitmapLayer(props, {
+        data: null,
+        image: props.data,
+        bounds: [west, south, east, north],
+        pickable: true
+      }));
+      break;
+    default:
+      console.error("Unknown tile mimeType", tileSource == null ? void 0 : tileSource.mimeType);
+  }
+  if (showTileBorders) {
+    layers.push(new import_layers.PathLayer({
+      id: `${props.id}-border`,
+      data: [
+        [
+          [west, north],
+          [west, south],
+          [east, south],
+          [east, north],
+          [west, north]
+        ]
+      ],
+      getPath: (d) => d,
+      getColor: borderColor,
+      widthMinPixels: 4
+    }));
+  }
+  return layers;
+}
+
+// dist/path-outline-layer/path-outline-layer.js
+var import_layers2 = require("@deck.gl/layers");
+var import_constants = require("@luma.gl/constants");
+
+// dist/path-outline-layer/outline.js
+var INITIAL_STATE = {
+  outlineEnabled: false,
+  outlineRenderShadowmap: false,
+  outlineShadowmap: null
+};
+function getUniforms({ outlineEnabled, outlineRenderShadowmap, outlineShadowmap } = INITIAL_STATE) {
+  const uniforms = {};
+  if (outlineEnabled !== void 0) {
+    uniforms.outline_uEnabled = outlineEnabled;
+  }
+  if (outlineRenderShadowmap !== void 0) {
+    uniforms.outline_uRenderOutlines = outlineRenderShadowmap;
+  }
+  if (outlineShadowmap !== void 0) {
+    uniforms.outline_uShadowmap = outlineShadowmap;
+  }
+  return uniforms;
+}
+var vs = `#version 300 es
+in float instanceZLevel;
+out float outline_vzLevel;
+out vec4 outline_vPosition;
+
+// Set the z level for the outline shadowmap rendering
+void outline_setZLevel(float zLevel) {
+  outline_vzLevel = zLevel;
+}
+
+// Store an adjusted position for texture2DProj
+void outline_setUV(vec4 position) {
+  // mat4(
+  //   0.5, 0.0, 0.0, 0.0,
+  //   0.0, 0.5, 0.0, 0.0,
+  //   0.0, 0.0, 0.5, 0.0,
+  //   0.5, 0.5, 0.5, 1.0
+  // ) * position;
+  outline_vPosition = vec4(position.xyz * 0.5 + position.w * 0.5, position.w);
+}
+`;
+var fs = `uniform bool outline_uEnabled;
+uniform bool outline_uRenderOutlines;
+uniform sampler2D outline_uShadowmap;
+
+in float outline_vzLevel;
+// in vec2 outline_vUV;
+in vec4 outline_vPosition;
+
+out vec4 fragColor;
+
+const float OUTLINE_Z_LEVEL_ERROR = 0.01;
+
+// Return a darker color in shadowmap
+vec4 outline_filterShadowColor(vec4 color) {
+  return vec4(outline_vzLevel / 255., outline_vzLevel / 255., outline_vzLevel / 255., 1.);
+}
+
+// Return a darker color if in shadowmap
+vec4 outline_filterDarkenColor(vec4 color) {
+  if (outline_uEnabled) {
+    float maxZLevel;
+    if (outline_vPosition.q > 0.0) {
+      maxZLevel = texture2DProj(outline_uShadowmap, outline_vPosition).r * 255.;
+    } else {
+      discard;
+    }
+    if (maxZLevel < outline_vzLevel + OUTLINE_Z_LEVEL_ERROR) {
+      vec4(color.rgb * 0.5, color.a);
+    } else {
+      discard;
+    }
+  }
+  return color;
+}
+
+// if enabled and rendering outlines - Render depth to shadowmap
+// if enabled and rendering colors - Return a darker color if in shadowmap
+// if disabled, just return color
+vec4 outline_filterColor(vec4 color) {
+  if (outline_uEnabled) {
+    return outline_uRenderOutlines ?
+      outline_filterShadowColor(color) :
+      outline_filterDarkenColor(color);
+  }
+  return color;
+}
+`;
+var outline = {
+  name: "outline",
+  vs,
+  fs,
+  getUniforms
+};
+
+// dist/path-outline-layer/path-outline-layer.js
+var UNIT = {
+  common: 0,
+  meters: 1,
+  pixels: 2
+};
+function injectShaderCode({ source, code = "" }) {
+  const INJECT_CODE = /}[^{}]*$/;
+  return source.replace(INJECT_CODE, code.concat("\n}\n"));
+}
+var VS_CODE = `  outline_setUV(gl_Position);
+  outline_setZLevel(instanceZLevel);
+`;
+var FS_CODE = `  fragColor = outline_filterColor(fragColor);
+`;
+var defaultProps = {
+  getZLevel: () => 0
+};
+var PathOutlineLayer = class extends import_layers2.PathLayer {
+  state = void 0;
+  // Override getShaders to inject the outline module
+  getShaders() {
+    const shaders = super.getShaders();
+    return Object.assign({}, shaders, {
+      modules: shaders.modules.concat([outline]),
+      vs: injectShaderCode({ source: shaders.vs, code: VS_CODE }),
+      fs: injectShaderCode({ source: shaders.fs, code: FS_CODE })
+    });
+  }
+  // @ts-expect-error PathLayer is missing LayerContext arg
+  initializeState(context) {
+    super.initializeState();
+    this.setState({
+      outlineFramebuffer: context.device.createFramebuffer({}),
+      dummyTexture: context.device.createTexture({})
+    });
+    this.state.attributeManager.addInstanced({
+      instanceZLevel: {
+        size: 1,
+        type: import_constants.GL.UNSIGNED_BYTE,
+        accessor: "getZLevel"
+      }
+    });
+  }
+  // Override draw to add render module
+  draw({ moduleParameters = {}, parameters, uniforms, context }) {
+    const { jointRounded, capRounded, billboard, miterLimit, widthUnits, widthScale, widthMinPixels, widthMaxPixels } = this.props;
+    uniforms = Object.assign({}, uniforms, {
+      jointType: Number(jointRounded),
+      capType: Number(capRounded),
+      billboard,
+      widthUnits: UNIT[widthUnits],
+      widthScale,
+      miterLimit,
+      widthMinPixels,
+      widthMaxPixels
+    });
+    const { outlineFramebuffer, dummyTexture } = this.state;
+    this.state.model.updateModuleSettings({
+      outlineEnabled: true,
+      outlineRenderShadowmap: true,
+      outlineShadowmap: dummyTexture
+    });
+    this.state.model.draw({
+      uniforms: Object.assign({}, uniforms, {
+        jointType: 0,
+        widthScale: this.props.widthScale * 1.3
+      }),
+      parameters: {
+        depthTest: false,
+        // Biggest value needs to go into buffer
+        blendEquation: import_constants.GL.MAX
+      },
+      framebuffer: outlineFramebuffer
+    });
+    this.state.model.updateModuleSettings({
+      outlineEnabled: true,
+      outlineRenderShadowmap: false,
+      outlineShadowmap: outlineFramebuffer
+    });
+    this.state.model.draw({
+      uniforms: Object.assign({}, uniforms, {
+        jointType: Number(jointRounded),
+        capType: Number(capRounded),
+        widthScale: this.props.widthScale
+      }),
+      parameters: {
+        depthTest: false
+      }
+    });
+  }
+};
+__publicField(PathOutlineLayer, "layerName", "PathOutlineLayer");
+__publicField(PathOutlineLayer, "defaultProps", defaultProps);
+
+// dist/path-marker-layer/path-marker-layer.js
+var import_core4 = require("@deck.gl/core");
+var import_layers3 = require("@deck.gl/layers");
+var import_mesh_layers = require("@deck.gl/mesh-layers");
+
+// dist/path-marker-layer/arrow-2d-geometry.js
+var import_engine = require("@luma.gl/engine");
+var Arrow2DGeometry = class extends import_engine.Geometry {
+  constructor(opts = {}) {
+    super(Object.assign({}, opts, {
+      attributes: getArrowAttributes(opts),
+      topology: "triangle-list"
+    }));
+  }
+};
+function getArrowAttributes({ length = 1, headSize = 0.2, tailWidth = 0.05, tailStart = 0.05 }) {
+  const texCoords = [
+    // HEAD
+    0.5,
+    1,
+    0,
+    0.5 - headSize / 2,
+    1 - headSize,
+    0,
+    0.5 + headSize / 2,
+    1 - headSize,
+    0,
+    0.5 - tailWidth / 2,
+    tailStart,
+    0,
+    0.5 + tailWidth / 2,
+    1 - headSize,
+    0,
+    0.5 + tailWidth / 2,
+    tailStart,
+    0,
+    0.5 - tailWidth / 2,
+    tailStart,
+    0,
+    0.5 - tailWidth / 2,
+    1 - headSize,
+    0,
+    0.5 + tailWidth / 2,
+    1 - headSize,
+    0
+  ];
+  const normals = [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1];
+  const positions = new Array(texCoords.length);
+  for (let i = 0; i < texCoords.length / 3; i++) {
+    const i3 = i * 3;
+    positions[i3 + 0] = (texCoords[i3 + 0] - 0.5) * length;
+    positions[i3 + 1] = (texCoords[i3 + 1] - 0.5) * length;
+    positions[i3 + 2] = 0;
+  }
+  return {
+    positions: { size: 3, value: new Float32Array(positions) },
+    normals: { size: 3, value: new Float32Array(normals) },
+    texCoords: { size: 2, value: new Float32Array(texCoords) }
+  };
+}
+
+// dist/path-marker-layer/create-path-markers.js
+var import_core2 = require("@math.gl/core");
+function getLineLength(vPoints) {
+  let lineLength = 0;
+  for (let i = 0; i < vPoints.length - 1; i++) {
+    lineLength += vPoints[i].distance(vPoints[i + 1]);
+  }
+  return lineLength;
+}
+var DEFAULT_COLOR = [0, 0, 0, 255];
+var DEFAULT_DIRECTION = { forward: true, backward: false };
+function createPathMarkers({ data, getPath = (x, context) => x.path, getDirection = (x) => x.direction, getColor = (x) => DEFAULT_COLOR, getMarkerPercentages = (x, info) => [0.5], projectFlat }) {
+  const markers = [];
+  for (const object of data) {
+    const path = getPath(object, null);
+    const direction = getDirection(object) || DEFAULT_DIRECTION;
+    const color = getColor(object);
+    const vPoints = path.map((p) => new import_core2.Vector2(p));
+    const vPointsReverse = vPoints.slice(0).reverse();
+    const lineLength = getLineLength(vPoints);
+    const percentages = getMarkerPercentages(object, { lineLength });
+    for (const percentage of percentages) {
+      if (direction.forward) {
+        const marker = createMarkerAlongPath({
+          path: vPoints,
+          percentage,
+          lineLength,
+          color,
+          object,
+          projectFlat
+        });
+        markers.push(marker);
+      }
+      if (direction.backward) {
+        const marker = createMarkerAlongPath({
+          path: vPointsReverse,
+          percentage,
+          lineLength,
+          color,
+          object,
+          projectFlat
+        });
+        markers.push(marker);
+      }
+    }
+  }
+  return markers;
+}
+function createMarkerAlongPath({ path, percentage, lineLength, color, object, projectFlat }) {
+  const distanceAlong = lineLength * percentage;
+  let currentDistance = 0;
+  let previousDistance = 0;
+  let i = 0;
+  for (i = 0; i < path.length - 1; i++) {
+    currentDistance += path[i].distance(path[i + 1]);
+    if (currentDistance > distanceAlong) {
+      break;
+    }
+    previousDistance = currentDistance;
+  }
+  if (i === path.length - 1) {
+    i -= 1;
+  }
+  const vDirection = path[i + 1].clone().subtract(path[i]).normalize();
+  const along = distanceAlong - previousDistance;
+  const vCenter = vDirection.clone().multiply(new import_core2.Vector2(along, along)).add(path[i]);
+  const vDirection2 = new import_core2.Vector2(projectFlat(path[i + 1])).subtract(projectFlat(path[i]));
+  const angle = vDirection2.verticalAngle() * 180 / Math.PI;
+  return { position: [vCenter.x, vCenter.y, 0], angle, color, object };
+}
+
+// dist/path-marker-layer/polyline.js
+var import_core3 = require("@math.gl/core");
+function getClosestPointOnLine({ p, p1, p2, clampToLine = true }) {
+  const lineVector = new import_core3.Vector3(p2).subtract(p1);
+  const pointVector = new import_core3.Vector3(p).subtract(p1);
+  let dotProduct = lineVector.dot(pointVector);
+  if (clampToLine) {
+    dotProduct = (0, import_core3.clamp)(dotProduct, 0, 1);
+  }
+  return lineVector.lerp(p1, p2, dotProduct);
+}
+function getClosestPointOnPolyline({ p, points }) {
+  p = new import_core3.Vector3(p);
+  let pClosest = null;
+  let distanceSquared = Infinity;
+  let index = -1;
+  for (let i = 0; i < points.length - 1; ++i) {
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const pClosestOnLine = getClosestPointOnLine({ p, p1, p2 });
+    const distanceToLineSquared = p.distanceSquared(pClosestOnLine);
+    if (distanceToLineSquared < distanceSquared) {
+      distanceSquared = distanceToLineSquared;
+      pClosest = pClosestOnLine;
+      index = i;
+    }
+  }
+  return {
+    point: pClosest,
+    index,
+    p1: points[index],
+    p2: points[index + 1],
+    distanceSquared,
+    distance: Math.sqrt(distanceSquared)
+  };
+}
+
+// dist/path-marker-layer/path-marker-layer.js
+var DISTANCE_FOR_MULTI_ARROWS = 0.1;
+var ARROW_HEAD_SIZE = 0.2;
+var ARROW_TAIL_WIDTH = 0.05;
+var DEFAULT_MARKER_LAYER = import_mesh_layers.SimpleMeshLayer;
+var DEFAULT_MARKER_LAYER_PROPS = {
+  mesh: new Arrow2DGeometry({ headSize: ARROW_HEAD_SIZE, tailWidth: ARROW_TAIL_WIDTH })
+};
+var defaultProps2 = Object.assign({}, PathOutlineLayer.defaultProps, {
+  MarkerLayer: DEFAULT_MARKER_LAYER,
+  markerLayerProps: DEFAULT_MARKER_LAYER_PROPS,
+  sizeScale: 100,
+  fp64: false,
+  highlightIndex: -1,
+  highlightPoint: null,
+  getPath: (x) => x.path,
+  getColor: (x) => x.color,
+  getMarkerColor: (x) => [0, 0, 0, 255],
+  getDirection: (x) => x.direction,
+  getMarkerPercentages: (object, { lineLength }) => lineLength > DISTANCE_FOR_MULTI_ARROWS ? [0.25, 0.5, 0.75] : [0.5]
+});
+var PathMarkerLayer = class extends import_core4.CompositeLayer {
+  state = void 0;
+  initializeState() {
+    this.state = {
+      markers: [],
+      mesh: new Arrow2DGeometry({ headSize: ARROW_HEAD_SIZE, tailWidth: ARROW_TAIL_WIDTH }),
+      closestPoint: null,
+      closestPoints: []
+    };
+  }
+  projectFlat(xyz, viewport, coordinateSystem, coordinateOrigin) {
+    if (coordinateSystem === import_core4.COORDINATE_SYSTEM.METER_OFFSETS) {
+      const [dx, dy] = viewport.metersToLngLatDelta(xyz);
+      const [x, y] = coordinateOrigin;
+      return viewport.projectFlat([x + dx, dy + y]);
+    } else if (coordinateSystem === import_core4.COORDINATE_SYSTEM.LNGLAT_OFFSETS) {
+      const [dx, dy] = xyz;
+      const [x, y] = coordinateOrigin;
+      return viewport.projectFlat([x + dx, dy + y]);
+    }
+    return viewport.projectFlat(xyz);
+  }
+  updateState({ props, oldProps, changeFlags }) {
+    if (changeFlags.dataChanged || changeFlags.updateTriggersChanged) {
+      const { data, getPath, getDirection, getMarkerColor, getMarkerPercentages, coordinateSystem, coordinateOrigin } = this.props;
+      const { viewport } = this.context;
+      const projectFlat = (o) => this.projectFlat(o, viewport, coordinateSystem, coordinateOrigin);
+      this.state.markers = createPathMarkers({
+        data,
+        getPath,
+        getDirection,
+        getColor: getMarkerColor,
+        getMarkerPercentages,
+        projectFlat
+      });
+      this._recalculateClosestPoint();
+    }
+    if (changeFlags.propsChanged) {
+      if (props.point !== oldProps.point) {
+        this._recalculateClosestPoint();
+      }
+    }
+  }
+  _recalculateClosestPoint() {
+    const { highlightPoint, highlightIndex } = this.props;
+    if (highlightPoint && highlightIndex >= 0) {
+      const object = this.props.data[highlightIndex];
+      const points = this.props.getPath(object, null);
+      const { point } = getClosestPointOnPolyline({ points, p: highlightPoint });
+      this.state.closestPoints = [{ position: point }];
+    } else {
+      this.state.closestPoints = [];
+    }
+  }
+  getPickingInfo({ info }) {
+    return Object.assign(info, {
+      // override object with picked feature
+      object: info.object && info.object.path || info.object
+    });
+  }
+  renderLayers() {
+    return [
+      new PathOutlineLayer(this.props, this.getSubLayerProps({
+        id: "paths",
+        // Note: data has to be passed explicitly like this to avoid being empty
+        data: this.props.data
+      })),
+      new this.props.MarkerLayer(this.getSubLayerProps(Object.assign({}, this.props.markerLayerProps, {
+        id: "markers",
+        data: this.state.markers,
+        getOrientation: (x) => [0, -x.angle, 0],
+        getColor: (x) => x.color,
+        sizeScale: this.props.sizeScale,
+        fp64: this.props.fp64,
+        pickable: false,
+        parameters: {
+          blend: false,
+          depthTest: false
+        }
+      }))),
+      this.state.closestPoints && new import_layers3.ScatterplotLayer({
+        id: `${this.props.id}-highlight`,
+        data: this.state.closestPoints,
+        fp64: this.props.fp64
+      })
+    ];
+  }
+};
+__publicField(PathMarkerLayer, "layerName", "PathMarkerLayer");
+__publicField(PathMarkerLayer, "defaultProps", defaultProps2);
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["index.js", "tile-source-layer/tile-source-layer.js", "path-outline-layer/path-outline-layer.js", "path-outline-layer/outline.js", "path-marker-layer/path-marker-layer.js", "path-marker-layer/arrow-2d-geometry.js", "path-marker-layer/create-path-markers.js", "path-marker-layer/polyline.js"],
+  "sourcesContent": ["// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport { TileSourceLayer } from './tile-source-layer/tile-source-layer';\nexport { PathOutlineLayer } from './path-outline-layer/path-outline-layer';\nexport { PathMarkerLayer } from './path-marker-layer/path-marker-layer';\n", "// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { CompositeLayer } from '@deck.gl/core';\nimport { TileLayer } from '@deck.gl/geo-layers';\nimport { BitmapLayer, GeoJsonLayer, PathLayer } from '@deck.gl/layers';\n/* global window */\nconst devicePixelRatio = (typeof window !== 'undefined' && window.devicePixelRatio) || 1;\n/**\n * A Deck.gl layer that renders a tile source\n * Autodiscovers type of content (vector tile, bitmap, ...)\n * Can render debug borders around tiles\n * TODO - Change debug border color based on zoom level\n */\nexport class TileSourceLayer extends CompositeLayer {\n    static layerName = 'TileSourceLayer';\n    static defaultProps = {\n        ...TileLayer.defaultProps,\n        showTileBorders: true\n    };\n    state = undefined;\n    initializeState() {\n        this.setState({\n            tileSource: null\n        });\n    }\n    updateState({ props, changeFlags }) {\n        this.setState({\n            tileSource: props.tileSource\n        });\n    }\n    renderLayers() {\n        const { tileSource, showTileBorders, metadata, onTilesLoad } = this.props;\n        const minZoom = metadata?.minZoom || 0;\n        const maxZoom = metadata?.maxZoom || 30;\n        return [\n            new TileLayer({\n                // HACK: Trigger new layer via id prop to force clear tile cache\n                id: String(tileSource.url),\n                getTileData: tileSource.getTileData,\n                // Assume the pmtiles file support HTTP/2, so we aren't limited by the browser to a certain number per domain.\n                maxRequests: 20,\n                pickable: true,\n                onViewportLoad: onTilesLoad,\n                autoHighlight: showTileBorders,\n                highlightColor: [60, 60, 60, 40],\n                minZoom,\n                maxZoom,\n                tileSize: 256,\n                // TOOD - why is this needed?\n                zoomOffset: devicePixelRatio === 1 ? -1 : 0,\n                renderSubLayers: renderSubLayers,\n                // Custom prop\n                tileSource,\n                showTileBorders\n            })\n        ];\n    }\n}\nfunction renderSubLayers(props) {\n    const { tileSource, showTileBorders, minZoom, maxZoom, tile: { index: { z: zoom }, bbox: { west, south, east, north } } } = props;\n    const layers = [];\n    const borderColor = zoom <= minZoom || zoom >= maxZoom ? [255, 0, 0, 255] : [0, 0, 255, 255];\n    switch (tileSource.mimeType) {\n        case 'application/vnd.mapbox-vector-tile':\n            layers.push(new GeoJsonLayer({\n                id: `${props.id}-geojson`,\n                data: props.data,\n                pickable: true,\n                getFillColor: [0, 190, 80, 255],\n                lineWidthScale: 500,\n                lineWidthMinPixels: 0.5\n            }));\n            break;\n        case 'image/png':\n        case 'image/jpeg':\n        case 'image/webp':\n        case 'image/avif':\n            layers.push(new BitmapLayer(props, {\n                data: null,\n                image: props.data,\n                bounds: [west, south, east, north],\n                pickable: true\n            }));\n            break;\n        default:\n            // eslint-disable-next-line no-console\n            console.error('Unknown tile mimeType', tileSource?.mimeType);\n    }\n    // Debug tile borders\n    if (showTileBorders) {\n        layers.push(new PathLayer({\n            id: `${props.id}-border`,\n            data: [\n                [\n                    [west, north],\n                    [west, south],\n                    [east, south],\n                    [east, north],\n                    [west, north]\n                ]\n            ],\n            getPath: (d) => d,\n            getColor: borderColor,\n            widthMinPixels: 4\n        }));\n    }\n    return layers;\n}\n", "// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { PathLayer } from '@deck.gl/layers';\nimport { GL } from '@luma.gl/constants';\nimport { outline } from './outline';\n/**\n * Unit literal to shader unit number conversion.\n */\nexport const UNIT = {\n    common: 0,\n    meters: 1,\n    pixels: 2\n};\n// TODO - this should be built into assembleShaders\nfunction injectShaderCode({ source, code = '' }) {\n    const INJECT_CODE = /}[^{}]*$/;\n    return source.replace(INJECT_CODE, code.concat('\\n}\\n'));\n}\nconst VS_CODE = `\\\n  outline_setUV(gl_Position);\n  outline_setZLevel(instanceZLevel);\n`;\nconst FS_CODE = `\\\n  fragColor = outline_filterColor(fragColor);\n`;\nconst defaultProps = {\n    getZLevel: () => 0\n};\nexport class PathOutlineLayer extends PathLayer {\n    static layerName = 'PathOutlineLayer';\n    static defaultProps = defaultProps;\n    state = undefined;\n    // Override getShaders to inject the outline module\n    getShaders() {\n        const shaders = super.getShaders();\n        return Object.assign({}, shaders, {\n            modules: shaders.modules.concat([outline]),\n            vs: injectShaderCode({ source: shaders.vs, code: VS_CODE }),\n            fs: injectShaderCode({ source: shaders.fs, code: FS_CODE })\n        });\n    }\n    // @ts-expect-error PathLayer is missing LayerContext arg\n    initializeState(context) {\n        super.initializeState();\n        // Create an outline \"shadow\" map\n        // TODO - we should create a single outlineMap for all layers\n        this.setState({\n            outlineFramebuffer: context.device.createFramebuffer({}),\n            dummyTexture: context.device.createTexture({})\n        });\n        // Create an attribute manager\n        // @ts-expect-error check whether this.getAttributeManager works here\n        this.state.attributeManager.addInstanced({\n            instanceZLevel: {\n                size: 1,\n                type: GL.UNSIGNED_BYTE,\n                accessor: 'getZLevel'\n            }\n        });\n    }\n    // Override draw to add render module\n    draw({ moduleParameters = {}, parameters, uniforms, context }) {\n        // Need to calculate same uniforms as base layer\n        const { jointRounded, capRounded, billboard, miterLimit, widthUnits, widthScale, widthMinPixels, widthMaxPixels } = this.props;\n        uniforms = Object.assign({}, uniforms, {\n            jointType: Number(jointRounded),\n            capType: Number(capRounded),\n            billboard,\n            widthUnits: UNIT[widthUnits],\n            widthScale,\n            miterLimit,\n            widthMinPixels,\n            widthMaxPixels\n        });\n        // Render the outline shadowmap (based on segment z orders)\n        const { outlineFramebuffer, dummyTexture } = this.state;\n        // TODO(v9): resize, see 'sf' example.\n        // outlineFramebuffer.resize();\n        // TODO(v9) clear FBO\n        // outlineFramebuffer.clear({ color: true, depth: true, stencil: true });\n        this.state.model.updateModuleSettings({\n            outlineEnabled: true,\n            outlineRenderShadowmap: true,\n            outlineShadowmap: dummyTexture\n        });\n        this.state.model.draw({\n            uniforms: Object.assign({}, uniforms, {\n                jointType: 0,\n                widthScale: this.props.widthScale * 1.3\n            }),\n            parameters: {\n                depthTest: false,\n                // Biggest value needs to go into buffer\n                blendEquation: GL.MAX\n            },\n            framebuffer: outlineFramebuffer\n        });\n        // Now use the outline shadowmap to render the lines (with outlines)\n        this.state.model.updateModuleSettings({\n            outlineEnabled: true,\n            outlineRenderShadowmap: false,\n            outlineShadowmap: outlineFramebuffer\n        });\n        this.state.model.draw({\n            uniforms: Object.assign({}, uniforms, {\n                jointType: Number(jointRounded),\n                capType: Number(capRounded),\n                widthScale: this.props.widthScale\n            }),\n            parameters: {\n                depthTest: false\n            }\n        });\n    }\n}\n", "// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/* eslint-disable camelcase */\nconst INITIAL_STATE = {\n    outlineEnabled: false,\n    outlineRenderShadowmap: false,\n    outlineShadowmap: null\n};\nfunction getUniforms({ outlineEnabled, outlineRenderShadowmap, outlineShadowmap } = INITIAL_STATE) {\n    const uniforms = {};\n    if (outlineEnabled !== undefined) {\n        // ? 1.0 : 0.0;\n        uniforms.outline_uEnabled = outlineEnabled;\n    }\n    if (outlineRenderShadowmap !== undefined) {\n        // ? 1.0 : 0.0;\n        uniforms.outline_uRenderOutlines = outlineRenderShadowmap;\n    }\n    if (outlineShadowmap !== undefined) {\n        uniforms.outline_uShadowmap = outlineShadowmap;\n    }\n    return uniforms;\n}\nconst vs = `\\\n#version 300 es\nin float instanceZLevel;\nout float outline_vzLevel;\nout vec4 outline_vPosition;\n\n// Set the z level for the outline shadowmap rendering\nvoid outline_setZLevel(float zLevel) {\n  outline_vzLevel = zLevel;\n}\n\n// Store an adjusted position for texture2DProj\nvoid outline_setUV(vec4 position) {\n  // mat4(\n  //   0.5, 0.0, 0.0, 0.0,\n  //   0.0, 0.5, 0.0, 0.0,\n  //   0.0, 0.0, 0.5, 0.0,\n  //   0.5, 0.5, 0.5, 1.0\n  // ) * position;\n  outline_vPosition = vec4(position.xyz * 0.5 + position.w * 0.5, position.w);\n}\n`;\nconst fs = `\\\nuniform bool outline_uEnabled;\nuniform bool outline_uRenderOutlines;\nuniform sampler2D outline_uShadowmap;\n\nin float outline_vzLevel;\n// in vec2 outline_vUV;\nin vec4 outline_vPosition;\n\nout vec4 fragColor;\n\nconst float OUTLINE_Z_LEVEL_ERROR = 0.01;\n\n// Return a darker color in shadowmap\nvec4 outline_filterShadowColor(vec4 color) {\n  return vec4(outline_vzLevel / 255., outline_vzLevel / 255., outline_vzLevel / 255., 1.);\n}\n\n// Return a darker color if in shadowmap\nvec4 outline_filterDarkenColor(vec4 color) {\n  if (outline_uEnabled) {\n    float maxZLevel;\n    if (outline_vPosition.q > 0.0) {\n      maxZLevel = texture2DProj(outline_uShadowmap, outline_vPosition).r * 255.;\n    } else {\n      discard;\n    }\n    if (maxZLevel < outline_vzLevel + OUTLINE_Z_LEVEL_ERROR) {\n      vec4(color.rgb * 0.5, color.a);\n    } else {\n      discard;\n    }\n  }\n  return color;\n}\n\n// if enabled and rendering outlines - Render depth to shadowmap\n// if enabled and rendering colors - Return a darker color if in shadowmap\n// if disabled, just return color\nvec4 outline_filterColor(vec4 color) {\n  if (outline_uEnabled) {\n    return outline_uRenderOutlines ?\n      outline_filterShadowColor(color) :\n      outline_filterDarkenColor(color);\n  }\n  return color;\n}\n`;\nexport const outline = {\n    name: 'outline',\n    vs,\n    fs,\n    getUniforms\n};\n", "// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { CompositeLayer, COORDINATE_SYSTEM } from '@deck.gl/core';\nimport { ScatterplotLayer } from '@deck.gl/layers';\nimport { SimpleMeshLayer } from '@deck.gl/mesh-layers';\nimport { PathOutlineLayer } from '../path-outline-layer/path-outline-layer';\nimport { Arrow2DGeometry } from './arrow-2d-geometry';\nimport { createPathMarkers } from './create-path-markers';\nimport { getClosestPointOnPolyline } from './polyline';\nconst DISTANCE_FOR_MULTI_ARROWS = 0.1;\nconst ARROW_HEAD_SIZE = 0.2;\nconst ARROW_TAIL_WIDTH = 0.05;\n// const ARROW_CENTER_ADJUST = -0.8;\nconst DEFAULT_MARKER_LAYER = SimpleMeshLayer;\nconst DEFAULT_MARKER_LAYER_PROPS = {\n    mesh: new Arrow2DGeometry({ headSize: ARROW_HEAD_SIZE, tailWidth: ARROW_TAIL_WIDTH })\n};\nconst defaultProps = Object.assign({}, PathOutlineLayer.defaultProps, {\n    MarkerLayer: DEFAULT_MARKER_LAYER,\n    markerLayerProps: DEFAULT_MARKER_LAYER_PROPS,\n    sizeScale: 100,\n    fp64: false,\n    highlightIndex: -1,\n    highlightPoint: null,\n    getPath: (x) => x.path,\n    getColor: (x) => x.color,\n    getMarkerColor: (x) => [0, 0, 0, 255],\n    getDirection: (x) => x.direction,\n    getMarkerPercentages: (object, { lineLength }) => lineLength > DISTANCE_FOR_MULTI_ARROWS ? [0.25, 0.5, 0.75] : [0.5]\n});\nexport class PathMarkerLayer extends CompositeLayer {\n    static layerName = 'PathMarkerLayer';\n    static defaultProps = defaultProps;\n    state = undefined;\n    initializeState() {\n        this.state = {\n            markers: [],\n            mesh: new Arrow2DGeometry({ headSize: ARROW_HEAD_SIZE, tailWidth: ARROW_TAIL_WIDTH }),\n            closestPoint: null,\n            closestPoints: []\n        };\n    }\n    projectFlat(xyz, viewport, coordinateSystem, coordinateOrigin) {\n        if (coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {\n            const [dx, dy] = viewport.metersToLngLatDelta(xyz);\n            const [x, y] = coordinateOrigin;\n            return viewport.projectFlat([x + dx, dy + y]);\n        }\n        else if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS) {\n            const [dx, dy] = xyz;\n            const [x, y] = coordinateOrigin;\n            return viewport.projectFlat([x + dx, dy + y]);\n        }\n        return viewport.projectFlat(xyz);\n    }\n    updateState({ props, oldProps, changeFlags }) {\n        if (changeFlags.dataChanged || changeFlags.updateTriggersChanged) {\n            const { data, getPath, getDirection, getMarkerColor, getMarkerPercentages, coordinateSystem, coordinateOrigin } = this.props;\n            const { viewport } = this.context;\n            const projectFlat = (o) => this.projectFlat(o, viewport, coordinateSystem, coordinateOrigin);\n            this.state.markers = createPathMarkers({\n                data,\n                getPath,\n                getDirection,\n                getColor: getMarkerColor,\n                getMarkerPercentages,\n                projectFlat\n            });\n            this._recalculateClosestPoint();\n        }\n        if (changeFlags.propsChanged) {\n            if (props.point !== oldProps.point) {\n                this._recalculateClosestPoint();\n            }\n        }\n    }\n    _recalculateClosestPoint() {\n        const { highlightPoint, highlightIndex } = this.props;\n        if (highlightPoint && highlightIndex >= 0) {\n            const object = this.props.data[highlightIndex];\n            const points = this.props.getPath(object, null);\n            const { point } = getClosestPointOnPolyline({ points, p: highlightPoint });\n            this.state.closestPoints = [{ position: point }];\n        }\n        else {\n            this.state.closestPoints = [];\n        }\n    }\n    getPickingInfo({ info }) {\n        return Object.assign(info, {\n            // override object with picked feature\n            object: (info.object && info.object.path) || info.object\n        });\n    }\n    renderLayers() {\n        return [\n            new PathOutlineLayer(this.props, this.getSubLayerProps({\n                id: 'paths',\n                // Note: data has to be passed explicitly like this to avoid being empty\n                data: this.props.data\n            })),\n            new this.props.MarkerLayer(this.getSubLayerProps(Object.assign({}, this.props.markerLayerProps, {\n                id: 'markers',\n                data: this.state.markers,\n                getOrientation: (x) => [0, -x.angle, 0],\n                getColor: (x) => x.color,\n                sizeScale: this.props.sizeScale,\n                fp64: this.props.fp64,\n                pickable: false,\n                parameters: {\n                    blend: false,\n                    depthTest: false\n                }\n            }))),\n            this.state.closestPoints &&\n                new ScatterplotLayer({\n                    id: `${this.props.id}-highlight`,\n                    data: this.state.closestPoints,\n                    fp64: this.props.fp64\n                })\n        ];\n    }\n}\n", "// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { Geometry } from '@luma.gl/engine';\nexport class Arrow2DGeometry extends Geometry {\n    constructor(opts = {}) {\n        super(Object.assign({}, opts, {\n            attributes: getArrowAttributes(opts),\n            topology: 'triangle-list'\n        }));\n    }\n}\nfunction getArrowAttributes({ length = 1, headSize = 0.2, tailWidth = 0.05, tailStart = 0.05 }) {\n    const texCoords = [\n        // HEAD\n        0.5,\n        1.0,\n        0,\n        0.5 - headSize / 2,\n        1.0 - headSize,\n        0,\n        0.5 + headSize / 2,\n        1.0 - headSize,\n        0,\n        0.5 - tailWidth / 2,\n        tailStart,\n        0,\n        0.5 + tailWidth / 2,\n        1.0 - headSize,\n        0,\n        0.5 + tailWidth / 2,\n        tailStart,\n        0,\n        0.5 - tailWidth / 2,\n        tailStart,\n        0,\n        0.5 - tailWidth / 2,\n        1.0 - headSize,\n        0,\n        0.5 + tailWidth / 2,\n        1.0 - headSize,\n        0\n    ];\n    const normals = [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1];\n    // Center and scale\n    const positions = new Array(texCoords.length);\n    for (let i = 0; i < texCoords.length / 3; i++) {\n        const i3 = i * 3;\n        positions[i3 + 0] = (texCoords[i3 + 0] - 0.5) * length;\n        positions[i3 + 1] = (texCoords[i3 + 1] - 0.5) * length;\n        positions[i3 + 2] = 0;\n    }\n    return {\n        positions: { size: 3, value: new Float32Array(positions) },\n        normals: { size: 3, value: new Float32Array(normals) },\n        texCoords: { size: 2, value: new Float32Array(texCoords) }\n    };\n}\n", "// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { Vector2 } from '@math.gl/core';\nfunction getLineLength(vPoints) {\n    // calculate total length\n    let lineLength = 0;\n    for (let i = 0; i < vPoints.length - 1; i++) {\n        lineLength += vPoints[i].distance(vPoints[i + 1]);\n    }\n    return lineLength;\n}\nconst DEFAULT_COLOR = [0, 0, 0, 255];\nconst DEFAULT_DIRECTION = { forward: true, backward: false };\nexport function createPathMarkers({ data, getPath = (x, context) => x.path, getDirection = (x) => x.direction, getColor = (x) => DEFAULT_COLOR, getMarkerPercentages = (x, info) => [0.5], projectFlat }) {\n    const markers = [];\n    for (const object of data) {\n        const path = getPath(object, null);\n        const direction = getDirection(object) || DEFAULT_DIRECTION;\n        const color = getColor(object);\n        const vPoints = path.map((p) => new Vector2(p));\n        const vPointsReverse = vPoints.slice(0).reverse();\n        // calculate total length\n        const lineLength = getLineLength(vPoints);\n        // Ask for where to put markers\n        const percentages = getMarkerPercentages(object, { lineLength });\n        // Create the markers\n        for (const percentage of percentages) {\n            if (direction.forward) {\n                const marker = createMarkerAlongPath({\n                    path: vPoints,\n                    percentage,\n                    lineLength,\n                    color,\n                    object,\n                    projectFlat\n                });\n                markers.push(marker);\n            }\n            if (direction.backward) {\n                const marker = createMarkerAlongPath({\n                    path: vPointsReverse,\n                    percentage,\n                    lineLength,\n                    color,\n                    object,\n                    projectFlat\n                });\n                markers.push(marker);\n            }\n        }\n    }\n    return markers;\n}\nfunction createMarkerAlongPath({ path, percentage, lineLength, color, object, projectFlat }) {\n    const distanceAlong = lineLength * percentage;\n    let currentDistance = 0;\n    let previousDistance = 0;\n    let i = 0;\n    for (i = 0; i < path.length - 1; i++) {\n        currentDistance += path[i].distance(path[i + 1]);\n        if (currentDistance > distanceAlong) {\n            break;\n        }\n        previousDistance = currentDistance;\n    }\n    // If reached the end of the loop without exiting early,\n    // undo the final increment to avoid a null-pointer exception\n    if (i === path.length - 1) {\n        i -= 1;\n    }\n    const vDirection = path[i + 1].clone().subtract(path[i]).normalize();\n    const along = distanceAlong - previousDistance;\n    const vCenter = vDirection.clone().multiply(new Vector2(along, along)).add(path[i]);\n    const vDirection2 = new Vector2(projectFlat(path[i + 1])).subtract(projectFlat(path[i]));\n    const angle = (vDirection2.verticalAngle() * 180) / Math.PI;\n    return { position: [vCenter.x, vCenter.y, 0], angle, color, object };\n}\n", "// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { Vector3, clamp } from '@math.gl/core';\n// Return the closest point on a line segment\nexport function getClosestPointOnLine({ p, p1, p2, clampToLine = true }) {\n    const lineVector = new Vector3(p2).subtract(p1);\n    const pointVector = new Vector3(p).subtract(p1);\n    let dotProduct = lineVector.dot(pointVector);\n    if (clampToLine) {\n        dotProduct = clamp(dotProduct, 0, 1);\n    }\n    return lineVector.lerp(p1, p2, dotProduct);\n}\n// Return the closest point on a line segment\nexport function getClosestPointOnPolyline({ p, points }) {\n    p = new Vector3(p);\n    let pClosest = null;\n    let distanceSquared = Infinity;\n    let index = -1;\n    for (let i = 0; i < points.length - 1; ++i) {\n        const p1 = points[i];\n        const p2 = points[i + 1];\n        const pClosestOnLine = getClosestPointOnLine({ p, p1, p2 });\n        const distanceToLineSquared = p.distanceSquared(pClosestOnLine);\n        if (distanceToLineSquared < distanceSquared) {\n            distanceSquared = distanceToLineSquared;\n            pClosest = pClosestOnLine;\n            index = i;\n        }\n    }\n    return {\n        point: pClosest,\n        index,\n        p1: points[index],\n        p2: points[index + 1],\n        distanceSquared,\n        distance: Math.sqrt(distanceSquared)\n    };\n}\n"],
+  "mappings": "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",
+  "names": ["import_layers", "import_core", "import_layers", "import_core", "import_core", "defaultProps"]
+}