@accelint/map-toolkit 2.0.0 → 3.0.0

package/dist/deckgl/extensions/coffin-corner/coffin-corner-extension.js

@@ -0,0 +1,535 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { createLoggerDomain } from "../../../shared/logger.js";
+import { LayerExtension } from "@deck.gl/core";
+import { IconLayer, ScatterplotLayer } from "@deck.gl/layers";
+
+//#region src/deckgl/extensions/coffin-corner/coffin-corner-extension.ts
+const logger = createLoggerDomain("[CoffinCornerExtension]");
+/**
+* Shader module defining the `highlightColor` uniform for coffin corner brackets.
+*
+* @property name - Module identifier used by deck.gl's shader assembly.
+* @property fs - Fragment shader (GLSL) source declaring the uniform block.
+* @property uniformTypes - Maps uniform names to WGSL-style type strings for deck.gl's uniform system.
+*
+* @remarks
+* GLSL type reference:
+*   - `float`   — single decimal number
+*   - `vec2`    — 2-component vector (x, y)
+*   - `vec3`    — 3-component vector (x, y, z) or (r, g, b)
+*   - `vec4`    — 4-component vector (x, y, z, w) or (r, g, b, a)
+*   - `uniform` — read-only value passed from JS to the GPU each frame
+*   - `in/out`  — values passed between vertex and fragment shader stages
+*/
+const coffinCornerModule = {
+	name: "coffinCorner",
+	fs: `\
+uniform coffinCornerUniforms {
+  vec4 highlightColor;  // RGBA color, each channel 0.0–1.0
+} coffinCorner;
+`,
+	uniformTypes: { highlightColor: "vec4<f32>" }
+};
+/**
+* Vertex declarations: per-instance attributes for selection/hover state,
+* passed to the fragment shader as varyings.
+*/
+const VS_DECL = `\
+in float instanceSelectedEntity;
+in float instanceHoveredEntity;
+out float vInstanceSelectedEntity; // v prefix is conventional for "varying"
+out float vInstanceHoveredEntity;
+`;
+/** Vertex main-end: forward per-instance attributes to the fragment shader. */
+const VS_MAIN_END = `\
+vInstanceSelectedEntity = instanceSelectedEntity;
+vInstanceHoveredEntity = instanceHoveredEntity;
+`;
+/**
+* ScatterplotLayer vertex declarations: adds `vQuadScale` varying to
+* communicate the quad expansion factor to the fragment shader.
+*/
+const SCATTERPLOT_VS_DECL = `\
+${VS_DECL}out float vQuadScale;
+`;
+/**
+* ScatterplotLayer vertex main-end: expands the quad when hovered/selected
+* to provide room for coffin corner brackets beyond the circle edge.
+*
+* The expansion multiplies `unitPosition` by the scale factor so that
+* fragment shader interpolation covers the larger area. The extra pixel
+* offset is added to `gl_Position` in clip space.
+*
+* References ScatterplotLayer vertex-scope variables:
+* `edgePadding`, `positions`, `outerRadiusPixels` (all still in scope at #main-end).
+*/
+const SCATTERPLOT_VS_MAIN_END = `\
+${VS_MAIN_END}
+// Expand the quad when hovered/selected to make room for bracket arms.
+// Scale factor 2.0 gives brackets the same visual footprint as the circle diameter.
+// Skip expansion in globe mode — clip-space XY manipulation causes depth conflicts
+// with the globe surface (known deck.gl limitation, see PR #9975).
+vQuadScale = 1.0;
+if ((instanceSelectedEntity > 0.5 || instanceHoveredEntity > 0.5)
+    && project.projectionMode != PROJECTION_MODE_GLOBE) {
+  vQuadScale = 2.0;
+  // Add extra offset in clip space (works for both billboard and non-billboard)
+  vec2 extraPixelOffset = (vQuadScale - 1.0) * edgePadding * positions.xy * outerRadiusPixels;
+  gl_Position.xy += project_pixel_size_to_clipspace(extraPixelOffset);
+  // Scale unitPosition so fragment interpolation covers the expanded quad
+  unitPosition *= vQuadScale;
+}
+`;
+/**
+* Fragment declarations: SDF functions for bracket rendering.
+*
+* Signed distance functions (SDF) return negative inside the shape,
+* zero on the edge, and positive outside. Used for anti-aliased rendering.
+*/
+const FS_DECL = `\
+in float vInstanceSelectedEntity;
+in float vInstanceHoveredEntity;
+
+/**
+ * Signed distance to an axis-aligned box.
+ *
+ * @param position - point to measure distance from
+ * @param halfExtents - half-width and half-height of the box (distance from center to each edge)
+ * @returns signed distance: negative inside, zero on edge, positive outside
+ */
+float coffinCorner_signedDistBox(vec2 position, vec2 halfExtents) {
+  vec2 dist = abs(position) - halfExtents;
+  return length(max(dist, 0.0)) + min(max(dist.x, dist.y), 0.0);
+}
+
+/**
+ * Signed distance to an L-shaped bracket arm (horizontal + vertical box union).
+ *
+ * @param position - point to measure distance from
+ * @param length - length of each arm of the L-shape (fraction of icon size)
+ * @param width - stroke width of each arm (fraction of icon size)
+ * @returns signed distance to the nearest arm of the L-shape
+ */
+float coffinCorner_signedDistBracketArm(vec2 position, float length, float width) {
+  float horizontalDist = coffinCorner_signedDistBox(position - vec2(length * 0.5, 0.0), vec2(length * 0.5, width * 0.5));
+  float verticalDist = coffinCorner_signedDistBox(position - vec2(0.0, length * 0.5), vec2(width * 0.5, length * 0.5));
+  return min(horizontalDist, verticalDist);
+}
+
+/**
+ * Minimum signed distance from a point to any of the four corner brackets.
+ *
+ * @param position - point in normalized space (-0.5 to 0.5)
+ * @param armLength - length of each bracket arm in UV units
+ * @param armWidth - stroke width of each bracket arm in UV units
+ * @returns signed distance to the nearest corner bracket
+ */
+float coffinCorner_allCorners(vec2 position, float armLength, float armWidth) {
+  const vec2 halfSize = vec2(0.5);
+
+  vec2 topLeft = position + halfSize;
+  vec2 topRight = vec2(halfSize.x - position.x, position.y + halfSize.y);
+  vec2 bottomLeft = vec2(position.x + halfSize.x, halfSize.y - position.y);
+  vec2 bottomRight = halfSize - position;
+
+  return min(
+    min(coffinCorner_signedDistBracketArm(topLeft, armLength, armWidth),
+        coffinCorner_signedDistBracketArm(topRight, armLength, armWidth)),
+    min(coffinCorner_signedDistBracketArm(bottomLeft, armLength, armWidth),
+        coffinCorner_signedDistBracketArm(bottomRight, armLength, armWidth))
+  );
+}
+
+/**
+ * Composite bracket visuals over a base color.
+ * Applies: hover fill → base color → black stroke → colored bracket fill.
+ * Returns the composited color — caller is responsible for writing to fragColor.
+ *
+ * @param baseColor - the layer's rendered color for this pixel (icon texture or circle fill)
+ * @param isHovered - whether the entity is hovered
+ * @param isSelected - whether the entity is selected
+ * @param strokeAlpha - alpha for the dilated black outline
+ * @param fillAlpha - alpha for the bracket fill shape
+ * @returns composited RGBA color
+ */
+vec4 coffinCorner_composite(
+  vec4 baseColor,
+  bool isHovered,
+  bool isSelected,
+  float strokeAlpha,
+  float fillAlpha
+) {
+  // Start with background fill (only when hovering) — white 30% opacity
+  vec4 result = isHovered
+    ? vec4(1.0, 1.0, 1.0, 0.3)
+    : vec4(0.0);  // no fill when just selected
+
+  // Composite base color OVER fill
+  result.rgb = baseColor.rgb * baseColor.a + result.rgb * result.a * (1.0 - baseColor.a);
+  result.a = baseColor.a + result.a * (1.0 - baseColor.a);
+
+  // Composite black stroke OVER base (dilated shape)
+  if (strokeAlpha > 0.01) {
+    vec3 strokeColor = vec3(0.0);  // Black
+    result.rgb = strokeColor * strokeAlpha + result.rgb * (1.0 - strokeAlpha);
+    result.a = strokeAlpha + result.a * (1.0 - strokeAlpha);
+  }
+
+  // Composite colored fill OVER stroke (normal shape)
+  if (fillAlpha > 0.01) {
+    vec4 cornerColor = isSelected
+      ? coffinCorner.highlightColor
+      : vec4(1.0);  // White fully opaque for hover-only
+    float blendedAlpha = fillAlpha * cornerColor.a;
+    result.rgb = cornerColor.rgb * blendedAlpha + result.rgb * (1.0 - blendedAlpha);
+    result.a = blendedAlpha + result.a * (1.0 - blendedAlpha);
+  }
+
+  return result;
+}
+`;
+/**
+* IconLayer `fs:#main-start` — samples `iconsTexture` to get the base icon color,
+* then composites brackets over it. References IconLayer-specific uniforms/varyings:
+* `iconsTexture`, `vTextureCoords`, `uv`.
+*/
+const ICON_FS_MAIN_START = `\
+  geometry.uv = uv; // uv = texture coordinate on the icon quad (ranges -1 to 1, center is 0,0)
+  bool isHovered = vInstanceHoveredEntity > 0.5;
+  bool isSelected = vInstanceSelectedEntity > 0.5;
+
+  if (isHovered || isSelected) {
+    vec2 bracketPos = uv * 0.5;  // map -1..1 to -0.5..0.5
+
+    // Check if inside the icon quad (the rectangular surface the icon texture is drawn on)
+    bool insideBox = max(abs(bracketPos.x), abs(bracketPos.y)) < 0.5;
+
+    // Distance from this pixel to the nearest bracket edge — drives stroke and fill alpha
+    float cornerDist = coffinCorner_allCorners(bracketPos, 0.26, 0.07);
+
+    // Outline width (proportional to icon)
+    float strokeWidth = 0.026;
+    // Anti-alias band: ~1 screen pixel regardless of icon size
+    float antiAlias = fwidth(cornerDist);
+
+    // strokeAlpha: expanded (dilated) shape for black border
+    // fillAlpha: true SDF edge for the bracket fill color
+    float strokeAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist + strokeWidth);
+    float fillAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist);
+
+    if (insideBox) {
+      // Sample icon texture (iconsTexture and vTextureCoords are provided by IconLayer's shader)
+      vec4 baseColor = texture(iconsTexture, vTextureCoords);
+
+      fragColor = coffinCorner_composite(baseColor, isHovered, isSelected, strokeAlpha, fillAlpha);
+      DECKGL_FILTER_COLOR(fragColor, geometry);
+      return;
+    }
+  }
+`;
+/**
+* ScatterplotLayer fragment declarations: adds `vQuadScale` varying
+* (received from the vertex shader) to the shared SDF function declarations.
+*/
+const SCATTERPLOT_FS_DECL = `\
+in float vQuadScale;
+${FS_DECL}`;
+/**
+* ScatterplotLayer `fs:#main-start` — replicates the circle rendering logic to get
+* the base fill/stroke color, then composites brackets over it.
+*
+* Uses two coordinate systems:
+* - **Original** (`originalUnit`): `unitPosition / vQuadScale` — maps back to
+*   the pre-expansion circle space (±1) for circle fill/stroke rendering.
+* - **Expanded** (`bracketPos`): `unitPosition / (2 * vQuadScale)` — maps the
+*   expanded quad to -0.5..0.5 for the bracket SDF.
+*
+* The vertex shader expands the quad by `vQuadScale` (2×) when hovered/selected,
+* giving the brackets room to render beyond the circle edge while keeping the circle
+* at its original visual size.
+*
+* References ScatterplotLayer-specific varyings/uniforms:
+* `unitPosition`, `outerRadiusPixels`, `innerUnitRadius`, `vFillColor`, `vLineColor`,
+* `scatterplot.antialiasing`, `scatterplot.stroked`, `scatterplot.filled`.
+*/
+const SCATTERPLOT_FS_MAIN_START = `\
+  geometry.uv = unitPosition;
+  bool isHovered = vInstanceHoveredEntity > 0.5;
+  bool isSelected = vInstanceSelectedEntity > 0.5;
+
+  if (isHovered || isSelected) {
+    // Bracket SDF coordinates: map the expanded quad to -0.5..0.5.
+    // Since both vertex positions and unitPosition were scaled by vQuadScale,
+    // the quad edge is at unitPosition ≈ ±(edgePadding * vQuadScale).
+    // Dividing by (2 * vQuadScale) maps ±vQuadScale to ±0.5.
+    // The circle edge (unitPosition = 1.0) maps to 1/(2*scale) ≈ 0.25 (for scale=2).
+    vec2 bracketPos = unitPosition / (2.0 * vQuadScale);
+
+    bool insideBox = max(abs(bracketPos.x), abs(bracketPos.y)) < 0.5;
+
+    // Arm proportions scaled for the expanded quad: the circle fills ~50% of the
+    // bracket box (circle edge at 0.25, bracket corner at 0.5). Shorter arms (0.15)
+    // keep L-shapes distinct instead of merging into a solid square.
+    float uvPerPx = fwidth(bracketPos.x);
+    float armLength = max(0.15, 6.0 * uvPerPx);   // min 6px arm length
+    float armWidth = max(0.04, 2.0 * uvPerPx);    // min 2px stroke width
+
+    float cornerDist = coffinCorner_allCorners(bracketPos, armLength, armWidth);
+    float strokeWidth = max(0.016, 1.0 * uvPerPx);     // min 1px outline
+    float antiAlias = fwidth(cornerDist);
+    float strokeAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist + strokeWidth);
+    float fillAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist);
+
+    if (insideBox) {
+      // Circle rendering uses unitPosition directly (NOT divided by vQuadScale).
+      // Because both the vertex positions and unitPosition were scaled equally in
+      // the vertex shader, the interpolated unitPosition at the circle-edge screen
+      // position is preserved at 1.0 — identical to the original shader's math.
+      float distToCenter = length(unitPosition) * outerRadiusPixels;
+      float inCircle = scatterplot.antialiasing
+        ? smoothedge(distToCenter, outerRadiusPixels)
+        : step(distToCenter, outerRadiusPixels);
+
+      vec4 baseColor = vec4(0.0);
+      if (inCircle > 0.0) {
+        if (scatterplot.stroked > 0.5) {
+          float isLine = scatterplot.antialiasing
+            ? smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter)
+            : step(innerUnitRadius * outerRadiusPixels, distToCenter);
+          if (scatterplot.filled > 0.5) {
+            baseColor = mix(vFillColor, vLineColor, isLine);
+          } else {
+            baseColor = vec4(vLineColor.rgb, vLineColor.a * isLine);
+          }
+        } else if (scatterplot.filled > 0.5) {
+          baseColor = vFillColor;
+        }
+        baseColor.a *= inCircle;
+      }
+
+      fragColor = coffinCorner_composite(baseColor, isHovered, isSelected, strokeAlpha, fillAlpha);
+      DECKGL_FILTER_COLOR(fragColor, geometry);
+      return;
+    }
+  }
+`;
+/**
+* Shader injection config for IconLayer.
+*
+* deck.gl inject keys follow the pattern `<stage>:<hook>`:
+*   - `vs:#decl`       — vertex shader, top-level declarations (before main)
+*   - `vs:#main-end`   — vertex shader, end of main()
+*   - `fs:#decl`       — fragment shader, top-level declarations (before main)
+*   - `fs:#main-start` — fragment shader, start of main()
+*/
+const ICON_SHADERS = {
+	modules: [coffinCornerModule],
+	inject: {
+		"vs:#decl": VS_DECL,
+		"vs:#main-end": VS_MAIN_END,
+		"fs:#decl": FS_DECL,
+		"fs:#main-start": ICON_FS_MAIN_START
+	}
+};
+/**
+* Shader injection config for ScatterplotLayer.
+* Uses scatterplot-specific vertex injections for quad expansion and
+* scatterplot-specific fragment declarations for the `vQuadScale` varying.
+*/
+const SCATTERPLOT_SHADERS = {
+	modules: [coffinCornerModule],
+	inject: {
+		"vs:#decl": SCATTERPLOT_VS_DECL,
+		"vs:#main-end": SCATTERPLOT_VS_MAIN_END,
+		"fs:#decl": SCATTERPLOT_FS_DECL,
+		"fs:#main-start": SCATTERPLOT_FS_MAIN_START
+	}
+};
+/** Default bracket fill color when selected: #39B7FA fully opaque. */
+const DEFAULT_SELECTED_CORNER_FILL = [
+	57,
+	183,
+	250,
+	255
+];
+/** Layer types supported by this extension. */
+const SUPPORTED_LAYERS = [IconLayer, ScatterplotLayer];
+/**
+* deck.gl layer extension that renders bracket-like "coffin corner" indicators
+* around hovered and selected map entities.
+*
+* Driven by explicit `hoveredEntityId` and `selectedEntityId` props rather than
+* deck.gl's built-in autoHighlight. Data objects are identified via the
+* `getEntityId` accessor (defaults to `item => item.id`).
+*
+* **Supported layer types:**
+* - **IconLayer** (and subclasses like SymbolLayer) — samples `iconsTexture`
+*   to re-composite the icon beneath the brackets.
+* - **ScatterplotLayer** — replicates the circle fill/stroke logic to composite
+*   the circle beneath the brackets.
+*
+* Using this extension on unsupported layer types will produce shader compilation
+* errors due to missing layer-specific uniforms/varyings.
+*
+* The host layer must set `pickable` to enable picking events.
+*
+* @see CoffinCornerExtensionProps for the full list of extension props.
+*
+* @example Fiber renderer JSX (IconLayer / SymbolLayer)
+* ```tsx
+* <symbolLayer
+*   {...props}
+*   pickable
+*   extensions={[new CoffinCornerExtension()]}
+*   selectedEntityId={selectedId}
+*   hoveredEntityId={hoveredId}
+* />
+* ```
+*
+* @example ScatterplotLayer
+* ```typescript
+* new ScatterplotLayer({
+*   extensions: [new CoffinCornerExtension()],
+*   getEntityId: (d) => d.id,
+*   selectedEntityId: selectedId,
+*   hoveredEntityId: hoveredId,
+* })
+* ```
+*
+* @example Custom entity ID accessor (e.g. GeoJSON features)
+* ```typescript
+* new IconLayer({
+*   extensions: [new CoffinCornerExtension()],
+*   getEntityId: (d) => d.properties?.shapeId,
+*   selectedEntityId: selectedShapeId,
+*   hoveredEntityId: hoveredShapeId,
+*   selectedCoffinCornerColor: [255, 0, 0, 255],
+* })
+* ```
+*/
+var CoffinCornerExtension = class CoffinCornerExtension extends LayerExtension {
+	static componentName = "CoffinCornerExtension";
+	static defaultProps = {
+		selectedEntityId: {
+			type: "value",
+			value: void 0
+		},
+		hoveredEntityId: {
+			type: "value",
+			value: void 0
+		},
+		selectedCoffinCornerColor: {
+			type: "color",
+			value: DEFAULT_SELECTED_CORNER_FILL
+		},
+		getEntityId: {
+			type: "accessor",
+			value: (item) => item.id
+		}
+	};
+	/** Returns true if the host layer is a supported type. */
+	static isSupportedLayer(layer) {
+		return SUPPORTED_LAYERS.some((LayerType) => layer instanceof LayerType);
+	}
+	/**
+	* Initializes selection and hover entity state maps and registers
+	* `instanceSelectedEntity` / `instanceHoveredEntity` GPU attributes.
+	* No-op on unsupported layer types (e.g. PathLayer, SolidPolygonLayer).
+	*/
+	initializeState() {
+		if (!CoffinCornerExtension.isSupportedLayer(this)) {
+			logger.warn(`CoffinCornerExtension supports IconLayer and ScatterplotLayer (and subclasses). Received: ${this.constructor.layerName}`);
+			return;
+		}
+		this.state.selectedEntities = /* @__PURE__ */ new Map();
+		this.state.hoveredEntities = /* @__PURE__ */ new Map();
+		const attributeManager = this.getAttributeManager();
+		if (!attributeManager) return;
+		const makeUpdateCallback = (stateKey) => (attribute, { data }) => {
+			const entities = this.state[stateKey];
+			const getId = this.props.getEntityId ?? ((item) => item.id);
+			const items = data ?? [];
+			const value = attribute.value;
+			for (let i = 0; i < items.length; i++) value[i] = entities.get(getId(items[i])) ?? 0;
+		};
+		attributeManager.addInstanced({
+			instanceSelectedEntity: {
+				size: 1,
+				update: makeUpdateCallback("selectedEntities")
+			},
+			instanceHoveredEntity: {
+				size: 1,
+				update: makeUpdateCallback("hoveredEntities")
+			}
+		});
+	}
+	/**
+	* Syncs `selectedEntityId` and `hoveredEntityId` prop changes into the
+	* entity state maps and invalidates the corresponding GPU attributes.
+	* No-op on unsupported layer types.
+	*
+	* @param params - The deck.gl update parameters containing current and previous props.
+	*/
+	updateState(params) {
+		if (!CoffinCornerExtension.isSupportedLayer(this)) return;
+		const attributeManager = this.getAttributeManager();
+		const newSelectedId = params.props.selectedEntityId;
+		const oldSelectedId = params.oldProps.selectedEntityId;
+		if (newSelectedId !== oldSelectedId) {
+			const { selectedEntities } = this.state;
+			if (oldSelectedId != null) selectedEntities.delete(oldSelectedId);
+			if (newSelectedId != null) selectedEntities.set(newSelectedId, 1);
+			attributeManager?.invalidate("instanceSelectedEntity");
+		}
+		const newHoveredId = params.props.hoveredEntityId;
+		const oldHoveredId = params.oldProps.hoveredEntityId;
+		if (newHoveredId !== oldHoveredId) {
+			const { hoveredEntities } = this.state;
+			if (oldHoveredId != null) hoveredEntities.delete(oldHoveredId);
+			if (newHoveredId != null) hoveredEntities.set(newHoveredId, 1);
+			attributeManager?.invalidate("instanceHoveredEntity");
+		}
+	}
+	/**
+	* Pushes the normalized `selectedCoffinCornerColor` to the shader's `highlightColor` uniform
+	* each frame. No-op on unsupported layer types.
+	*/
+	draw() {
+		if (!CoffinCornerExtension.isSupportedLayer(this)) return;
+		const color = this.props.selectedCoffinCornerColor ?? DEFAULT_SELECTED_CORNER_FILL;
+		this.setShaderModuleProps({ coffinCorner: { highlightColor: [
+			color[0] / 255,
+			color[1] / 255,
+			color[2] / 255,
+			color[3] / 255
+		] } });
+	}
+	/**
+	* Returns the appropriate shader injection config based on the host layer type.
+	* IconLayer gets texture-sampling shaders; ScatterplotLayer gets circle-replicating shaders.
+	* Returns null for unsupported layer types to skip shader injection.
+	*
+	* @returns The vertex/fragment shader injection config and uniform module, or null.
+	*/
+	getShaders(_extensions) {
+		if (this instanceof ScatterplotLayer) return SCATTERPLOT_SHADERS;
+		if (this instanceof IconLayer) return ICON_SHADERS;
+		return null;
+	}
+};
+
+//#endregion
+export { CoffinCornerExtension };
+//# sourceMappingURL=coffin-corner-extension.js.map

package/dist/deckgl/extensions/coffin-corner/coffin-corner-extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coffin-corner-extension.js","names":["coffinCornerModule: {\n  name: string;\n  fs: string;\n  uniformTypes: Record<string, string>;\n}","DEFAULT_SELECTED_CORNER_FILL: Rgba255Tuple"],"sources":["../../../../src/deckgl/extensions/coffin-corner/coffin-corner-extension.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { LayerExtension } from '@deck.gl/core';\nimport { IconLayer, ScatterplotLayer } from '@deck.gl/layers';\nimport { createLoggerDomain } from '@/shared/logger';\nimport type { Rgba255Tuple } from '@accelint/predicates';\nimport type { Layer, UpdateParameters } from '@deck.gl/core';\nimport type { CoffinCornerExtensionProps, EntityId } from './types';\n\nconst logger = createLoggerDomain('[CoffinCornerExtension]');\n\n/** Layer shape with coffin-corner selection and hover state maps. */\ntype CoffinCornerLayer = Layer & {\n  state: {\n    selectedEntities: Map<EntityId, number>;\n    hoveredEntities: Map<EntityId, number>;\n  };\n};\n\n/**\n * Shader module defining the `highlightColor` uniform for coffin corner brackets.\n *\n * @property name - Module identifier used by deck.gl's shader assembly.\n * @property fs - Fragment shader (GLSL) source declaring the uniform block.\n * @property uniformTypes - Maps uniform names to WGSL-style type strings for deck.gl's uniform system.\n *\n * @remarks\n * GLSL type reference:\n *   - `float`   — single decimal number\n *   - `vec2`    — 2-component vector (x, y)\n *   - `vec3`    — 3-component vector (x, y, z) or (r, g, b)\n *   - `vec4`    — 4-component vector (x, y, z, w) or (r, g, b, a)\n *   - `uniform` — read-only value passed from JS to the GPU each frame\n *   - `in/out`  — values passed between vertex and fragment shader stages\n */\nconst coffinCornerModule: {\n  name: string;\n  fs: string;\n  uniformTypes: Record<string, string>;\n} = {\n  name: 'coffinCorner',\n  fs: /* glsl */ `\\\nuniform coffinCornerUniforms {\n  vec4 highlightColor;  // RGBA color, each channel 0.0–1.0\n} coffinCorner;\n`,\n  uniformTypes: {\n    highlightColor: 'vec4<f32>', // WGSL-style type: 4-component vector of 32-bit floats (deck.gl convention)\n  },\n};\n\n// -- Shared shader injections (IconLayer and ScatterplotLayer) --\n\n/**\n * Vertex declarations: per-instance attributes for selection/hover state,\n * passed to the fragment shader as varyings.\n */\nconst VS_DECL = /* glsl */ `\\\nin float instanceSelectedEntity;\nin float instanceHoveredEntity;\nout float vInstanceSelectedEntity; // v prefix is conventional for \"varying\"\nout float vInstanceHoveredEntity;\n`;\n\n/** Vertex main-end: forward per-instance attributes to the fragment shader. */\nconst VS_MAIN_END = /* glsl */ `\\\nvInstanceSelectedEntity = instanceSelectedEntity;\nvInstanceHoveredEntity = instanceHoveredEntity;\n`;\n\n// -- ScatterplotLayer-specific vertex shader injections --\n\n/**\n * ScatterplotLayer vertex declarations: adds `vQuadScale` varying to\n * communicate the quad expansion factor to the fragment shader.\n */\nconst SCATTERPLOT_VS_DECL = /* glsl */ `\\\n${VS_DECL}out float vQuadScale;\n`;\n\n/**\n * ScatterplotLayer vertex main-end: expands the quad when hovered/selected\n * to provide room for coffin corner brackets beyond the circle edge.\n *\n * The expansion multiplies `unitPosition` by the scale factor so that\n * fragment shader interpolation covers the larger area. The extra pixel\n * offset is added to `gl_Position` in clip space.\n *\n * References ScatterplotLayer vertex-scope variables:\n * `edgePadding`, `positions`, `outerRadiusPixels` (all still in scope at #main-end).\n */\nconst SCATTERPLOT_VS_MAIN_END = /* glsl */ `\\\n${VS_MAIN_END}\n// Expand the quad when hovered/selected to make room for bracket arms.\n// Scale factor 2.0 gives brackets the same visual footprint as the circle diameter.\n// Skip expansion in globe mode — clip-space XY manipulation causes depth conflicts\n// with the globe surface (known deck.gl limitation, see PR #9975).\nvQuadScale = 1.0;\nif ((instanceSelectedEntity > 0.5 || instanceHoveredEntity > 0.5)\n    && project.projectionMode != PROJECTION_MODE_GLOBE) {\n  vQuadScale = 2.0;\n  // Add extra offset in clip space (works for both billboard and non-billboard)\n  vec2 extraPixelOffset = (vQuadScale - 1.0) * edgePadding * positions.xy * outerRadiusPixels;\n  gl_Position.xy += project_pixel_size_to_clipspace(extraPixelOffset);\n  // Scale unitPosition so fragment interpolation covers the expanded quad\n  unitPosition *= vQuadScale;\n}\n`;\n\n/**\n * Fragment declarations: SDF functions for bracket rendering.\n *\n * Signed distance functions (SDF) return negative inside the shape,\n * zero on the edge, and positive outside. Used for anti-aliased rendering.\n */\nconst FS_DECL = /* glsl */ `\\\nin float vInstanceSelectedEntity;\nin float vInstanceHoveredEntity;\n\n/**\n * Signed distance to an axis-aligned box.\n *\n * @param position - point to measure distance from\n * @param halfExtents - half-width and half-height of the box (distance from center to each edge)\n * @returns signed distance: negative inside, zero on edge, positive outside\n */\nfloat coffinCorner_signedDistBox(vec2 position, vec2 halfExtents) {\n  vec2 dist = abs(position) - halfExtents;\n  return length(max(dist, 0.0)) + min(max(dist.x, dist.y), 0.0);\n}\n\n/**\n * Signed distance to an L-shaped bracket arm (horizontal + vertical box union).\n *\n * @param position - point to measure distance from\n * @param length - length of each arm of the L-shape (fraction of icon size)\n * @param width - stroke width of each arm (fraction of icon size)\n * @returns signed distance to the nearest arm of the L-shape\n */\nfloat coffinCorner_signedDistBracketArm(vec2 position, float length, float width) {\n  float horizontalDist = coffinCorner_signedDistBox(position - vec2(length * 0.5, 0.0), vec2(length * 0.5, width * 0.5));\n  float verticalDist = coffinCorner_signedDistBox(position - vec2(0.0, length * 0.5), vec2(width * 0.5, length * 0.5));\n  return min(horizontalDist, verticalDist);\n}\n\n/**\n * Minimum signed distance from a point to any of the four corner brackets.\n *\n * @param position - point in normalized space (-0.5 to 0.5)\n * @param armLength - length of each bracket arm in UV units\n * @param armWidth - stroke width of each bracket arm in UV units\n * @returns signed distance to the nearest corner bracket\n */\nfloat coffinCorner_allCorners(vec2 position, float armLength, float armWidth) {\n  const vec2 halfSize = vec2(0.5);\n\n  vec2 topLeft = position + halfSize;\n  vec2 topRight = vec2(halfSize.x - position.x, position.y + halfSize.y);\n  vec2 bottomLeft = vec2(position.x + halfSize.x, halfSize.y - position.y);\n  vec2 bottomRight = halfSize - position;\n\n  return min(\n    min(coffinCorner_signedDistBracketArm(topLeft, armLength, armWidth),\n        coffinCorner_signedDistBracketArm(topRight, armLength, armWidth)),\n    min(coffinCorner_signedDistBracketArm(bottomLeft, armLength, armWidth),\n        coffinCorner_signedDistBracketArm(bottomRight, armLength, armWidth))\n  );\n}\n\n/**\n * Composite bracket visuals over a base color.\n * Applies: hover fill → base color → black stroke → colored bracket fill.\n * Returns the composited color — caller is responsible for writing to fragColor.\n *\n * @param baseColor - the layer's rendered color for this pixel (icon texture or circle fill)\n * @param isHovered - whether the entity is hovered\n * @param isSelected - whether the entity is selected\n * @param strokeAlpha - alpha for the dilated black outline\n * @param fillAlpha - alpha for the bracket fill shape\n * @returns composited RGBA color\n */\nvec4 coffinCorner_composite(\n  vec4 baseColor,\n  bool isHovered,\n  bool isSelected,\n  float strokeAlpha,\n  float fillAlpha\n) {\n  // Start with background fill (only when hovering) — white 30% opacity\n  vec4 result = isHovered\n    ? vec4(1.0, 1.0, 1.0, 0.3)\n    : vec4(0.0);  // no fill when just selected\n\n  // Composite base color OVER fill\n  result.rgb = baseColor.rgb * baseColor.a + result.rgb * result.a * (1.0 - baseColor.a);\n  result.a = baseColor.a + result.a * (1.0 - baseColor.a);\n\n  // Composite black stroke OVER base (dilated shape)\n  if (strokeAlpha > 0.01) {\n    vec3 strokeColor = vec3(0.0);  // Black\n    result.rgb = strokeColor * strokeAlpha + result.rgb * (1.0 - strokeAlpha);\n    result.a = strokeAlpha + result.a * (1.0 - strokeAlpha);\n  }\n\n  // Composite colored fill OVER stroke (normal shape)\n  if (fillAlpha > 0.01) {\n    vec4 cornerColor = isSelected\n      ? coffinCorner.highlightColor\n      : vec4(1.0);  // White fully opaque for hover-only\n    float blendedAlpha = fillAlpha * cornerColor.a;\n    result.rgb = cornerColor.rgb * blendedAlpha + result.rgb * (1.0 - blendedAlpha);\n    result.a = blendedAlpha + result.a * (1.0 - blendedAlpha);\n  }\n\n  return result;\n}\n`;\n\n// -- Layer-specific fragment shader main-start injections --\n\n/**\n * IconLayer `fs:#main-start` — samples `iconsTexture` to get the base icon color,\n * then composites brackets over it. References IconLayer-specific uniforms/varyings:\n * `iconsTexture`, `vTextureCoords`, `uv`.\n */\nconst ICON_FS_MAIN_START = /* glsl */ `\\\n  geometry.uv = uv; // uv = texture coordinate on the icon quad (ranges -1 to 1, center is 0,0)\n  bool isHovered = vInstanceHoveredEntity > 0.5;\n  bool isSelected = vInstanceSelectedEntity > 0.5;\n\n  if (isHovered || isSelected) {\n    vec2 bracketPos = uv * 0.5;  // map -1..1 to -0.5..0.5\n\n    // Check if inside the icon quad (the rectangular surface the icon texture is drawn on)\n    bool insideBox = max(abs(bracketPos.x), abs(bracketPos.y)) < 0.5;\n\n    // Distance from this pixel to the nearest bracket edge — drives stroke and fill alpha\n    float cornerDist = coffinCorner_allCorners(bracketPos, 0.26, 0.07);\n\n    // Outline width (proportional to icon)\n    float strokeWidth = 0.026;\n    // Anti-alias band: ~1 screen pixel regardless of icon size\n    float antiAlias = fwidth(cornerDist);\n\n    // strokeAlpha: expanded (dilated) shape for black border\n    // fillAlpha: true SDF edge for the bracket fill color\n    float strokeAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist + strokeWidth);\n    float fillAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist);\n\n    if (insideBox) {\n      // Sample icon texture (iconsTexture and vTextureCoords are provided by IconLayer's shader)\n      vec4 baseColor = texture(iconsTexture, vTextureCoords);\n\n      fragColor = coffinCorner_composite(baseColor, isHovered, isSelected, strokeAlpha, fillAlpha);\n      DECKGL_FILTER_COLOR(fragColor, geometry);\n      return;\n    }\n  }\n`;\n\n/**\n * ScatterplotLayer fragment declarations: adds `vQuadScale` varying\n * (received from the vertex shader) to the shared SDF function declarations.\n */\nconst SCATTERPLOT_FS_DECL = /* glsl */ `\\\nin float vQuadScale;\n${FS_DECL}`;\n\n/**\n * ScatterplotLayer `fs:#main-start` — replicates the circle rendering logic to get\n * the base fill/stroke color, then composites brackets over it.\n *\n * Uses two coordinate systems:\n * - **Original** (`originalUnit`): `unitPosition / vQuadScale` — maps back to\n *   the pre-expansion circle space (±1) for circle fill/stroke rendering.\n * - **Expanded** (`bracketPos`): `unitPosition / (2 * vQuadScale)` — maps the\n *   expanded quad to -0.5..0.5 for the bracket SDF.\n *\n * The vertex shader expands the quad by `vQuadScale` (2×) when hovered/selected,\n * giving the brackets room to render beyond the circle edge while keeping the circle\n * at its original visual size.\n *\n * References ScatterplotLayer-specific varyings/uniforms:\n * `unitPosition`, `outerRadiusPixels`, `innerUnitRadius`, `vFillColor`, `vLineColor`,\n * `scatterplot.antialiasing`, `scatterplot.stroked`, `scatterplot.filled`.\n */\nconst SCATTERPLOT_FS_MAIN_START = /* glsl */ `\\\n  geometry.uv = unitPosition;\n  bool isHovered = vInstanceHoveredEntity > 0.5;\n  bool isSelected = vInstanceSelectedEntity > 0.5;\n\n  if (isHovered || isSelected) {\n    // Bracket SDF coordinates: map the expanded quad to -0.5..0.5.\n    // Since both vertex positions and unitPosition were scaled by vQuadScale,\n    // the quad edge is at unitPosition ≈ ±(edgePadding * vQuadScale).\n    // Dividing by (2 * vQuadScale) maps ±vQuadScale to ±0.5.\n    // The circle edge (unitPosition = 1.0) maps to 1/(2*scale) ≈ 0.25 (for scale=2).\n    vec2 bracketPos = unitPosition / (2.0 * vQuadScale);\n\n    bool insideBox = max(abs(bracketPos.x), abs(bracketPos.y)) < 0.5;\n\n    // Arm proportions scaled for the expanded quad: the circle fills ~50% of the\n    // bracket box (circle edge at 0.25, bracket corner at 0.5). Shorter arms (0.15)\n    // keep L-shapes distinct instead of merging into a solid square.\n    float uvPerPx = fwidth(bracketPos.x);\n    float armLength = max(0.15, 6.0 * uvPerPx);   // min 6px arm length\n    float armWidth = max(0.04, 2.0 * uvPerPx);    // min 2px stroke width\n\n    float cornerDist = coffinCorner_allCorners(bracketPos, armLength, armWidth);\n    float strokeWidth = max(0.016, 1.0 * uvPerPx);     // min 1px outline\n    float antiAlias = fwidth(cornerDist);\n    float strokeAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist + strokeWidth);\n    float fillAlpha = 1.0 - smoothstep(0.0, antiAlias, cornerDist);\n\n    if (insideBox) {\n      // Circle rendering uses unitPosition directly (NOT divided by vQuadScale).\n      // Because both the vertex positions and unitPosition were scaled equally in\n      // the vertex shader, the interpolated unitPosition at the circle-edge screen\n      // position is preserved at 1.0 — identical to the original shader's math.\n      float distToCenter = length(unitPosition) * outerRadiusPixels;\n      float inCircle = scatterplot.antialiasing\n        ? smoothedge(distToCenter, outerRadiusPixels)\n        : step(distToCenter, outerRadiusPixels);\n\n      vec4 baseColor = vec4(0.0);\n      if (inCircle > 0.0) {\n        if (scatterplot.stroked > 0.5) {\n          float isLine = scatterplot.antialiasing\n            ? smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter)\n            : step(innerUnitRadius * outerRadiusPixels, distToCenter);\n          if (scatterplot.filled > 0.5) {\n            baseColor = mix(vFillColor, vLineColor, isLine);\n          } else {\n            baseColor = vec4(vLineColor.rgb, vLineColor.a * isLine);\n          }\n        } else if (scatterplot.filled > 0.5) {\n          baseColor = vFillColor;\n        }\n        baseColor.a *= inCircle;\n      }\n\n      fragColor = coffinCorner_composite(baseColor, isHovered, isSelected, strokeAlpha, fillAlpha);\n      DECKGL_FILTER_COLOR(fragColor, geometry);\n      return;\n    }\n  }\n`;\n\n// -- Shader configs --\n\n/**\n * Shader injection config for IconLayer.\n *\n * deck.gl inject keys follow the pattern `<stage>:<hook>`:\n *   - `vs:#decl`       — vertex shader, top-level declarations (before main)\n *   - `vs:#main-end`   — vertex shader, end of main()\n *   - `fs:#decl`       — fragment shader, top-level declarations (before main)\n *   - `fs:#main-start` — fragment shader, start of main()\n */\nconst ICON_SHADERS = {\n  modules: [coffinCornerModule],\n  inject: {\n    'vs:#decl': VS_DECL,\n    'vs:#main-end': VS_MAIN_END,\n    'fs:#decl': FS_DECL,\n    'fs:#main-start': ICON_FS_MAIN_START,\n  },\n};\n\n/**\n * Shader injection config for ScatterplotLayer.\n * Uses scatterplot-specific vertex injections for quad expansion and\n * scatterplot-specific fragment declarations for the `vQuadScale` varying.\n */\nconst SCATTERPLOT_SHADERS = {\n  modules: [coffinCornerModule],\n  inject: {\n    'vs:#decl': SCATTERPLOT_VS_DECL,\n    'vs:#main-end': SCATTERPLOT_VS_MAIN_END,\n    'fs:#decl': SCATTERPLOT_FS_DECL,\n    'fs:#main-start': SCATTERPLOT_FS_MAIN_START,\n  },\n};\n\n/** Default bracket fill color when selected: #39B7FA fully opaque. */\nconst DEFAULT_SELECTED_CORNER_FILL: Rgba255Tuple = [57, 183, 250, 255];\n\n/** Layer types supported by this extension. */\nconst SUPPORTED_LAYERS = [IconLayer, ScatterplotLayer];\n\n// -- Extension class --\n\n/**\n * deck.gl layer extension that renders bracket-like \"coffin corner\" indicators\n * around hovered and selected map entities.\n *\n * Driven by explicit `hoveredEntityId` and `selectedEntityId` props rather than\n * deck.gl's built-in autoHighlight. Data objects are identified via the\n * `getEntityId` accessor (defaults to `item => item.id`).\n *\n * **Supported layer types:**\n * - **IconLayer** (and subclasses like SymbolLayer) — samples `iconsTexture`\n *   to re-composite the icon beneath the brackets.\n * - **ScatterplotLayer** — replicates the circle fill/stroke logic to composite\n *   the circle beneath the brackets.\n *\n * Using this extension on unsupported layer types will produce shader compilation\n * errors due to missing layer-specific uniforms/varyings.\n *\n * The host layer must set `pickable` to enable picking events.\n *\n * @see CoffinCornerExtensionProps for the full list of extension props.\n *\n * @example Fiber renderer JSX (IconLayer / SymbolLayer)\n * ```tsx\n * <symbolLayer\n *   {...props}\n *   pickable\n *   extensions={[new CoffinCornerExtension()]}\n *   selectedEntityId={selectedId}\n *   hoveredEntityId={hoveredId}\n * />\n * ```\n *\n * @example ScatterplotLayer\n * ```typescript\n * new ScatterplotLayer({\n *   extensions: [new CoffinCornerExtension()],\n *   getEntityId: (d) => d.id,\n *   selectedEntityId: selectedId,\n *   hoveredEntityId: hoveredId,\n * })\n * ```\n *\n * @example Custom entity ID accessor (e.g. GeoJSON features)\n * ```typescript\n * new IconLayer({\n *   extensions: [new CoffinCornerExtension()],\n *   getEntityId: (d) => d.properties?.shapeId,\n *   selectedEntityId: selectedShapeId,\n *   hoveredEntityId: hoveredShapeId,\n *   selectedCoffinCornerColor: [255, 0, 0, 255],\n * })\n * ```\n */\nexport class CoffinCornerExtension extends LayerExtension {\n  static override componentName = 'CoffinCornerExtension';\n\n  static override defaultProps = {\n    selectedEntityId: { type: 'value', value: undefined },\n    hoveredEntityId: { type: 'value', value: undefined },\n    selectedCoffinCornerColor: {\n      type: 'color',\n      value: DEFAULT_SELECTED_CORNER_FILL,\n    },\n    getEntityId: {\n      type: 'accessor',\n      value: (item: { id: EntityId }) => item.id,\n    },\n  };\n\n  /** Returns true if the host layer is a supported type. */\n  private static isSupportedLayer(layer: Layer): boolean {\n    return SUPPORTED_LAYERS.some((LayerType) => layer instanceof LayerType);\n  }\n\n  /**\n   * Initializes selection and hover entity state maps and registers\n   * `instanceSelectedEntity` / `instanceHoveredEntity` GPU attributes.\n   * No-op on unsupported layer types (e.g. PathLayer, SolidPolygonLayer).\n   */\n  override initializeState(this: CoffinCornerLayer) {\n    if (!CoffinCornerExtension.isSupportedLayer(this)) {\n      logger.warn(\n        `CoffinCornerExtension supports IconLayer and ScatterplotLayer (and subclasses). Received: ${(this.constructor as typeof Layer).layerName}`,\n      );\n      return;\n    }\n\n    this.state.selectedEntities = new Map<EntityId, number>();\n    this.state.hoveredEntities = new Map<EntityId, number>();\n\n    const attributeManager = this.getAttributeManager();\n    if (!attributeManager) {\n      return;\n    }\n\n    const makeUpdateCallback =\n      (stateKey: 'selectedEntities' | 'hoveredEntities') =>\n      (\n        attribute: { value: unknown },\n        { data }: { data: unknown[] | undefined },\n      ) => {\n        const entities = this.state[stateKey];\n        const getId =\n          (this.props as unknown as CoffinCornerExtensionProps).getEntityId ??\n          // biome-ignore lint/suspicious/noExplicitAny: Default accessor assumes item.id exists.\n          ((item: any) => item.id as EntityId);\n        const items = data ?? [];\n        const value = attribute.value as Float32Array;\n\n        for (let i = 0; i < items.length; i++) {\n          value[i] = entities.get(getId(items[i])) ?? 0;\n        }\n      };\n\n    attributeManager.addInstanced({\n      instanceSelectedEntity: {\n        size: 1,\n        update: makeUpdateCallback('selectedEntities'),\n      },\n      instanceHoveredEntity: {\n        size: 1,\n        update: makeUpdateCallback('hoveredEntities'),\n      },\n    });\n  }\n\n  /**\n   * Syncs `selectedEntityId` and `hoveredEntityId` prop changes into the\n   * entity state maps and invalidates the corresponding GPU attributes.\n   * No-op on unsupported layer types.\n   *\n   * @param params - The deck.gl update parameters containing current and previous props.\n   */\n  override updateState(\n    this: CoffinCornerLayer,\n    params: UpdateParameters<Layer<CoffinCornerExtensionProps>>,\n  ) {\n    if (!CoffinCornerExtension.isSupportedLayer(this)) {\n      return;\n    }\n\n    const attributeManager = this.getAttributeManager();\n\n    // Selection state\n    const newSelectedId = params.props.selectedEntityId;\n    const oldSelectedId = params.oldProps.selectedEntityId;\n    if (newSelectedId !== oldSelectedId) {\n      const { selectedEntities } = this.state;\n      if (oldSelectedId != null) {\n        selectedEntities.delete(oldSelectedId);\n      }\n      if (newSelectedId != null) {\n        selectedEntities.set(newSelectedId, 1);\n      }\n      attributeManager?.invalidate('instanceSelectedEntity');\n    }\n\n    // Hover state\n    const newHoveredId = params.props.hoveredEntityId;\n    const oldHoveredId = params.oldProps.hoveredEntityId;\n    if (newHoveredId !== oldHoveredId) {\n      const { hoveredEntities } = this.state;\n      if (oldHoveredId != null) {\n        hoveredEntities.delete(oldHoveredId);\n      }\n      if (newHoveredId != null) {\n        hoveredEntities.set(newHoveredId, 1);\n      }\n      attributeManager?.invalidate('instanceHoveredEntity');\n    }\n  }\n\n  /**\n   * Pushes the normalized `selectedCoffinCornerColor` to the shader's `highlightColor` uniform\n   * each frame. No-op on unsupported layer types.\n   */\n  override draw(this: CoffinCornerLayer) {\n    if (!CoffinCornerExtension.isSupportedLayer(this)) {\n      return;\n    }\n\n    const color =\n      (this.props as unknown as CoffinCornerExtensionProps)\n        .selectedCoffinCornerColor ?? DEFAULT_SELECTED_CORNER_FILL;\n\n    this.setShaderModuleProps({\n      coffinCorner: {\n        highlightColor: [\n          color[0] / 255,\n          color[1] / 255,\n          color[2] / 255,\n          color[3] / 255,\n        ],\n      },\n    });\n  }\n\n  /**\n   * Returns the appropriate shader injection config based on the host layer type.\n   * IconLayer gets texture-sampling shaders; ScatterplotLayer gets circle-replicating shaders.\n   * Returns null for unsupported layer types to skip shader injection.\n   *\n   * @returns The vertex/fragment shader injection config and uniform module, or null.\n   */\n  override getShaders(this: CoffinCornerLayer, _extensions: this) {\n    if (this instanceof ScatterplotLayer) {\n      return SCATTERPLOT_SHADERS;\n    }\n    if (this instanceof IconLayer) {\n      return ICON_SHADERS;\n    }\n    return null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,MAAM,SAAS,mBAAmB,0BAA0B;;;;;;;;;;;;;;;;;AA0B5D,MAAMA,qBAIF;CACF,MAAM;CACN,IAAe;;;;;CAKf,cAAc,EACZ,gBAAgB,aACjB;CACF;;;;;AAQD,MAAM,UAAqB;;;;;;;AAQ3B,MAAM,cAAyB;;;;;;;;AAW/B,MAAM,sBAAiC;EACrC,QAAQ;;;;;;;;;;;;;AAcV,MAAM,0BAAqC;EACzC,YAAY;;;;;;;;;;;;;;;;;;;;;;AAuBd,MAAM,UAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8G3B,MAAM,qBAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCtC,MAAM,sBAAiC;;EAErC;;;;;;;;;;;;;;;;;;;AAoBF,MAAM,4BAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyE7C,MAAM,eAAe;CACnB,SAAS,CAAC,mBAAmB;CAC7B,QAAQ;EACN,YAAY;EACZ,gBAAgB;EAChB,YAAY;EACZ,kBAAkB;EACnB;CACF;;;;;;AAOD,MAAM,sBAAsB;CAC1B,SAAS,CAAC,mBAAmB;CAC7B,QAAQ;EACN,YAAY;EACZ,gBAAgB;EAChB,YAAY;EACZ,kBAAkB;EACnB;CACF;;AAGD,MAAMC,+BAA6C;CAAC;CAAI;CAAK;CAAK;CAAI;;AAGtE,MAAM,mBAAmB,CAAC,WAAW,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDtD,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,gBAAgB;CAEhC,OAAgB,eAAe;EAC7B,kBAAkB;GAAE,MAAM;GAAS,OAAO;GAAW;EACrD,iBAAiB;GAAE,MAAM;GAAS,OAAO;GAAW;EACpD,2BAA2B;GACzB,MAAM;GACN,OAAO;GACR;EACD,aAAa;GACX,MAAM;GACN,QAAQ,SAA2B,KAAK;GACzC;EACF;;CAGD,OAAe,iBAAiB,OAAuB;AACrD,SAAO,iBAAiB,MAAM,cAAc,iBAAiB,UAAU;;;;;;;CAQzE,AAAS,kBAAyC;AAChD,MAAI,CAAC,sBAAsB,iBAAiB,KAAK,EAAE;AACjD,UAAO,KACL,6FAA8F,KAAK,YAA6B,YACjI;AACD;;AAGF,OAAK,MAAM,mCAAmB,IAAI,KAAuB;AACzD,OAAK,MAAM,kCAAkB,IAAI,KAAuB;EAExD,MAAM,mBAAmB,KAAK,qBAAqB;AACnD,MAAI,CAAC,iBACH;EAGF,MAAM,sBACH,cAEC,WACA,EAAE,WACC;GACH,MAAM,WAAW,KAAK,MAAM;GAC5B,MAAM,QACH,KAAK,MAAgD,iBAEpD,SAAc,KAAK;GACvB,MAAM,QAAQ,QAAQ,EAAE;GACxB,MAAM,QAAQ,UAAU;AAExB,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,IAChC,OAAM,KAAK,SAAS,IAAI,MAAM,MAAM,GAAG,CAAC,IAAI;;AAIlD,mBAAiB,aAAa;GAC5B,wBAAwB;IACtB,MAAM;IACN,QAAQ,mBAAmB,mBAAmB;IAC/C;GACD,uBAAuB;IACrB,MAAM;IACN,QAAQ,mBAAmB,kBAAkB;IAC9C;GACF,CAAC;;;;;;;;;CAUJ,AAAS,YAEP,QACA;AACA,MAAI,CAAC,sBAAsB,iBAAiB,KAAK,CAC/C;EAGF,MAAM,mBAAmB,KAAK,qBAAqB;EAGnD,MAAM,gBAAgB,OAAO,MAAM;EACnC,MAAM,gBAAgB,OAAO,SAAS;AACtC,MAAI,kBAAkB,eAAe;GACnC,MAAM,EAAE,qBAAqB,KAAK;AAClC,OAAI,iBAAiB,KACnB,kBAAiB,OAAO,cAAc;AAExC,OAAI,iBAAiB,KACnB,kBAAiB,IAAI,eAAe,EAAE;AAExC,qBAAkB,WAAW,yBAAyB;;EAIxD,MAAM,eAAe,OAAO,MAAM;EAClC,MAAM,eAAe,OAAO,SAAS;AACrC,MAAI,iBAAiB,cAAc;GACjC,MAAM,EAAE,oBAAoB,KAAK;AACjC,OAAI,gBAAgB,KAClB,iBAAgB,OAAO,aAAa;AAEtC,OAAI,gBAAgB,KAClB,iBAAgB,IAAI,cAAc,EAAE;AAEtC,qBAAkB,WAAW,wBAAwB;;;;;;;CAQzD,AAAS,OAA8B;AACrC,MAAI,CAAC,sBAAsB,iBAAiB,KAAK,CAC/C;EAGF,MAAM,QACH,KAAK,MACH,6BAA6B;AAElC,OAAK,qBAAqB,EACxB,cAAc,EACZ,gBAAgB;GACd,MAAM,KAAK;GACX,MAAM,KAAK;GACX,MAAM,KAAK;GACX,MAAM,KAAK;GACZ,EACF,EACF,CAAC;;;;;;;;;CAUJ,AAAS,WAAoC,aAAmB;AAC9D,MAAI,gBAAgB,iBAClB,QAAO;AAET,MAAI,gBAAgB,UAClB,QAAO;AAET,SAAO"}

package/dist/deckgl/extensions/coffin-corner/index.d.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { CoffinCornerDeselectedEvent, CoffinCornerEvent, CoffinCornerEventType, CoffinCornerEvents, CoffinCornerExtensionProps, CoffinCornerHoveredEvent, CoffinCornerSelectedEvent, EntityId } from "./types.js";
+import { CoffinCornerExtension } from "./coffin-corner-extension.js";
+import { clearSelection, coffinCornerStore, getHoveredEntityId, getSelectedEntityId } from "./store.js";
+import { UseCoffinCornerOptions, UseCoffinCornerReturn, useCoffinCorner } from "./use-coffin-corner.js";
+export { type CoffinCornerDeselectedEvent, type CoffinCornerEvent, type CoffinCornerEventType, CoffinCornerEvents, CoffinCornerExtension, type CoffinCornerExtensionProps, type CoffinCornerHoveredEvent, type CoffinCornerSelectedEvent, type EntityId, type UseCoffinCornerOptions, type UseCoffinCornerReturn, clearSelection, coffinCornerStore, getHoveredEntityId, getSelectedEntityId, useCoffinCorner };

package/dist/deckgl/extensions/coffin-corner/index.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { CoffinCornerExtension } from "./coffin-corner-extension.js";
+import { CoffinCornerEvents } from "./types.js";
+import { clearSelection, coffinCornerStore, getHoveredEntityId, getSelectedEntityId } from "./store.js";
+import { useCoffinCorner } from "./use-coffin-corner.js";
+
+export { CoffinCornerEvents, CoffinCornerExtension, clearSelection, coffinCornerStore, getHoveredEntityId, getSelectedEntityId, useCoffinCorner };