@powsybl/network-map-layers 2.0.0 → 3.0.0

package/dist/powsybl-network-map-layers.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants$1 = require("@luma.gl/constants");
+const engine = require("@luma.gl/engine");
 const core = require("@deck.gl/core");
-const GL = require("@luma.gl/constants");
-const core$1 = require("@luma.gl/core");
 const extensions = require("@deck.gl/extensions");
 const layers = require("@deck.gl/layers");
 var EQUIPMENT_TYPES = /* @__PURE__ */ ((EQUIPMENT_TYPES2) => {
@@ -25,6 +25,8 @@ var EQUIPMENT_TYPES = /* @__PURE__ */ ((EQUIPMENT_TYPES2) => {
   EQUIPMENT_TYPES2["SWITCH"] = "SWITCH";
   return EQUIPMENT_TYPES2;
 })(EQUIPMENT_TYPES || {});
+const isMapSubstation = (object) => "voltageLevels" in object;
+const isMapLine = (object) => "id" in object && "voltageLevelId1" in object && "voltageLevelId2" in object;
 const factors = {
   kilometers: 1,
   miles: 1e3 / 1609.344,
@@ -1667,82 +1669,71 @@ wktToPolygon$1.default = _default;
     return obj && obj.__esModule ? obj : { default: obj };
   }
 })(es);
-const vs = `/**
+const vs = `#version 300 es
+#define SHADER_NAME "arrow-layer-vertex-shader"
+
+/**
  * Copyright (c) 2022, RTE (http://www.rte-france.com)
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#define SHADER_NAME "arrow-layer-vertex-shader"
-
 precision highp float;
 
-attribute vec3 positions;
-
-attribute float instanceSize;
-attribute float instanceArrowDistance;
-attribute vec4 instanceColor;
-attribute float instanceSpeedFactor;
-attribute float instanceLinePositionsTextureOffset;
-attribute float instanceLineDistancesTextureOffset;
-attribute float instanceLinePointCount;
-attribute float instanceLineDistance;
-attribute float instanceArrowDirection;
-attribute float instanceLineParallelIndex;
-attribute vec3 instanceLineAngles;
-attribute vec2 instanceProximityFactors;
+in vec3 positions;
+in float instanceSize;
+in vec4 instanceColor;
+in float instanceSpeedFactor;
+in float instanceArrowDistance;
+in float instanceArrowDirection;
+in float instanceLineDistance;
+in int instanceLinePositionsTextureOffset;
+in int instanceLineDistancesTextureOffset;
+in int instanceLinePointCount;
+in float instanceLineParallelIndex;
+in vec3 instanceLineAngles;
+in vec2 instanceProximityFactors;
+in float instanceDistanceBetweenLines;
 
 uniform float sizeMinPixels;
 uniform float sizeMaxPixels;
 uniform float timestamp;
 uniform sampler2D linePositionsTexture;
 uniform sampler2D lineDistancesTexture;
-uniform ivec2 linePositionsTextureSize;
-uniform ivec2 lineDistancesTextureSize;
-uniform float webgl2;
-uniform float distanceBetweenLines;
 uniform float maxParallelOffset;
 uniform float minParallelOffset;
 uniform float opacity;
+uniform ivec2 linePositionsTextureSize;
 
-varying vec4 vFillColor;
-varying float shouldDiscard;
+uniform ivec2 lineDistancesTextureSize;
 
-vec4 texelFetch(sampler2D sampler, ivec2 index, ivec2 size) {
-    float x = (2.0 * float(index.x) + 1.0) / (2.0 * float(size.x));
-    float y = (2.0 * float(index.y) + 1.0) / (2.0 * float(size.y));
-    return texture2D(sampler, vec2(x, y));
-}
+flat out vec4 vFillColor;
+flat out float shouldDiscard;
 
 /**
  * Calculate 2 dimensions texture index from flat index.
  */
 ivec2 calculateTextureIndex(int flatIndex, ivec2 textureSize) {
-    int x = flatIndex - flatIndex / textureSize.x * textureSize.x;
-    int y = flatIndex / textureSize.y;
-    return ivec2(x, y);
+    return ivec2(flatIndex % textureSize.x, flatIndex / textureSize.x);
 }
 
 /**
  * Fetch WGS84 position from texture for a given point of the line.
  */
 vec3 fetchLinePosition(int point) {
-    int flatIndex = int(instanceLinePositionsTextureOffset) + point;
+    int flatIndex = instanceLinePositionsTextureOffset + point;
     ivec2 textureIndex = calculateTextureIndex(flatIndex, linePositionsTextureSize);
-    vec4 color = texelFetch(linePositionsTexture, textureIndex, linePositionsTextureSize);
-    float x = color.r;
-    float y = webgl2 > 0.5 ? color.g : color.a;
-    return vec3(x, y, 0);
+    return vec3(texelFetch(linePositionsTexture, textureIndex, 0).xy, 0);
 }
 
 /**
  * Fetch distance (in meters from the start of the line) from texture for a point of the line.
  */
 float fetchLineDistance(int point) {
-    int flatIndex = int(instanceLineDistancesTextureOffset) + point;
+    int flatIndex = instanceLineDistancesTextureOffset + point;
     ivec2 textureIndex = calculateTextureIndex(flatIndex, lineDistancesTextureSize);
-    return texelFetch(lineDistancesTexture, textureIndex, lineDistancesTextureSize).r;
+    return texelFetch(lineDistancesTexture, textureIndex, 0).x;
 }
 
 /**
@@ -1762,25 +1753,21 @@ float fetchLineDistance(int point) {
  */
 int findFirstLinePointAfterDistance(float distance) {
     int firstPoint = 0;
-    int lastPoint = int(instanceLinePointCount) - 1;
+    int lastPoint = instanceLinePointCount - 1;
 
-    // variable length loops are not supported in WebGL v1, it needs to be a constant and cannot be like in WebGL v2 an
-    // attribute, so we suppose here that we won't have more that 2^log2MaxPointCount points per line...
-    //
-    // WARNING!!!!
-    // also, we need to avoid break/return in the for loop even if search complete because with a WebGL1 browser
-    // it is not possible to call texture2D inside a non deterministic piece of code
-    // https://shadertoyunofficial.wordpress.com/2017/11/19/avoiding-compiler-crash-or-endless-compilation
-    const int log2MaxPointCount = 15;
-    for (int i = 0; i < log2MaxPointCount; i++) {
-        if (firstPoint + 1 != lastPoint) {
-            int middlePoint = (firstPoint + lastPoint) / 2;
-            float middlePointDistance = fetchLineDistance(middlePoint);
-            if (middlePointDistance <= distance) {
-                firstPoint = middlePoint;
-            } else {
-                lastPoint = middlePoint;
-            }
+    // variable length loops are now supported in GLSL with OpenGL ES 3.0+,
+    // instanceLinePointCount is an upper bound that
+    // will never be reached as binary search complexity is in O(log(instanceLinePointCount))
+    for (int i = 0; i < instanceLinePointCount; i++) {
+        if (firstPoint + 1 == lastPoint) {
+            return lastPoint;
+        }
+        int middlePoint = (firstPoint + lastPoint) / 2;
+        float middlePointDistance = fetchLineDistance(middlePoint);
+        if (middlePointDistance <= distance) {
+            firstPoint = middlePoint;
+        } else {
+            lastPoint = middlePoint;
         }
     }
     return lastPoint;
@@ -1791,7 +1778,7 @@ mat3 calculateRotation(vec3 commonPosition1, vec3 commonPosition2) {
     if (instanceArrowDirection < 2.0) {
         angle += radians(180.0);
     }
-    return mat3(cos(angle), sin(angle), 0, -sin(angle), cos(angle), 0, 0, 0, 0);
+    return mat3(cos(angle), sin(angle), 0.0, -sin(angle), cos(angle), 0.0, 0.0, 0.0, 1.0);
 }
 
 /**
@@ -1823,16 +1810,18 @@ float project_size_all_zoom_levels(float meters, float lat) {
 
 void main(void ) {
     if (instanceArrowDirection < 1.0) {
-        vFillColor = vec4(0, 0, 0, 0);
+        vFillColor = vec4(0.0);
         shouldDiscard = 1.0;
     } else {
         // arrow distance from the line start shifted with current timestamp
         // instanceArrowDistance: a float in interval [0,1] describing the initial position of the arrow along the full path between two substations (0: begin, 1.0 end)
-        float arrowDistance = mod(
+        float distanceAlong =
             instanceLineDistance * instanceArrowDistance +
-                (instanceArrowDirection < 2.0 ? 1.0 : -1.0) * timestamp * instanceSpeedFactor,
-            instanceLineDistance
-        );
+            (instanceArrowDirection < 2.0 ? 1.0 : -1.0) * timestamp * instanceSpeedFactor;
+        float arrowDistance = mod(distanceAlong, instanceLineDistance);
+        if (arrowDistance < 0.0) {
+            arrowDistance += instanceLineDistance;
+        }
 
         // look for first line point that is after arrow distance
         int linePoint = findFirstLinePointAfterDistance(arrowDistance);
@@ -1840,7 +1829,8 @@ void main(void ) {
         // Interpolate the 2 line points position
         float lineDistance1 = fetchLineDistance(linePoint - 1);
         float lineDistance2 = fetchLineDistance(linePoint);
-        float interpolationValue = (arrowDistance - lineDistance1) / (lineDistance2 - lineDistance1);
+        float denom = max(1e-6, lineDistance2 - lineDistance1);
+        float interpolationValue = clamp((arrowDistance - lineDistance1) / denom, 0.0, 1.0);
 
         // position for the line point just before the arrow
         vec3 linePosition1 = fetchLinePosition(linePoint - 1);
@@ -1861,7 +1851,7 @@ void main(void ) {
         // This hack does not seem necessary for parallel-path or fork-line layers.
         vec3 arrowPositionWorldSpace = mix(linePosition1, linePosition2, interpolationValue);
         float offsetCommonSpace = clamp(
-            project_size_all_zoom_levels(distanceBetweenLines, arrowPositionWorldSpace.y),
+            project_size_all_zoom_levels(instanceDistanceBetweenLines, arrowPositionWorldSpace.y),
             project_pixel_size(minParallelOffset),
             project_pixel_size(maxParallelOffset)
         );
@@ -1909,7 +1899,7 @@ void main(void ) {
     }
 }
 `;
-const fs = '/**\n * Copyright (c) 2022, RTE (http://www.rte-france.com)\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\n#define SHADER_NAME "arrow-layer-fragment-shader"\n\nprecision highp float;\n\nvarying vec4 vFillColor;\nvarying float shouldDiscard;\n\nvoid main(void ) {\n    if (shouldDiscard > 0.0) {\n        discard;\n    }\n    gl_FragColor = vFillColor;\n}\n';
+const fs = '#version 300 es\n#define SHADER_NAME "arrow-layer-fragment-shader"\nprecision highp float;\n\n/**\n * Copyright (c) 2022, RTE (http://www.rte-france.com)\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nflat in vec4 vFillColor;\nflat in float shouldDiscard;\nout vec4 fragmentColor;\n\nvoid main(void) {\n    if (shouldDiscard > 0.0) {\n        discard;\n    }\n    fragmentColor = vFillColor;\n}\n';
 const DEFAULT_COLOR = [0, 0, 0, 255];
 const MAX_LINE_POINT_COUNT = 2 ** 15;
 var ArrowDirection = /* @__PURE__ */ ((ArrowDirection2) => {
@@ -1937,11 +1927,9 @@ const defaultProps$3 = {
   animated: { type: "boolean", value: true },
   getLineParallelIndex: { type: "accessor", value: 0 },
   getLineAngles: { type: "accessor", value: [0, 0, 0] },
-  // @ts-expect-error TODO TS2322: distanceBetweenLines does not exist in type DefaultProps<ArrowLayerProps>. Did you mean to write getDistanceBetweenLines?
-  distanceBetweenLines: { type: "number", value: 1e3 },
   maxParallelOffset: { type: "number", value: 100 },
-  minParallelOffset: { type: "number", value: 3 },
-  opacity: { type: "number", value: 1 }
+  minParallelOffset: { type: "number", value: 3 }
+  // opacity prop is handled at the layer level for visually proportional perception https://deck.gl/docs/api-reference/core/layer#opacity
 };
 const _ArrowLayer = class _ArrowLayer extends core.Layer {
   getShaders() {
@@ -1959,20 +1947,16 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
     }
     return attributes;
   }
-  initializeState() {
+  initializeState({ device }) {
     var _a;
-    const { gl } = this.context;
-    if (!core$1.hasFeatures(gl, [core$1.FEATURES.TEXTURE_FLOAT])) {
-      throw new Error("Arrow layer not supported on this browser");
-    }
-    const maxTextureSize = gl.getParameter(GL.MAX_TEXTURE_SIZE);
+    const maxTextureSize = device.limits.maxTextureDimension2D;
     this.state = {
-      maxTextureSize,
-      webgl2: core$1.isWebGL2(gl)
+      maxTextureSize
     };
     (_a = this.getAttributeManager()) == null ? void 0 : _a.addInstanced({
       instanceSize: {
         size: 1,
+        type: "float32",
         transition: true,
         accessor: "getSize",
         defaultValue: 1
@@ -1980,13 +1964,14 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
       instanceColor: {
         size: this.props.colorFormat.length,
         transition: true,
-        normalized: true,
-        type: GL.UNSIGNED_BYTE,
+        type: "unorm8",
+        // normalized: true,
         accessor: "getColor",
         defaultValue: [0, 0, 0, 255]
       },
       instanceSpeedFactor: {
         size: 1,
+        type: "float32",
         transition: true,
         accessor: "getSpeedFactor",
         defaultValue: 1
@@ -1995,11 +1980,12 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
         size: 1,
         transition: true,
         accessor: "getDistance",
-        type: GL.FLOAT,
+        type: "float32",
         defaultValue: 0
       },
       instanceArrowDirection: {
         size: 1,
+        type: "float32",
         transition: true,
         accessor: "getDirection",
         transform: (direction) => {
@@ -2019,41 +2005,48 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
       instanceLineDistance: {
         size: 1,
         transition: true,
-        type: GL.FLOAT,
+        type: "float32",
         accessor: (arrow) => this.getArrowLineAttributes(arrow).distance
       },
       instanceLinePositionsTextureOffset: {
         size: 1,
         transition: true,
-        type: GL.FLOAT,
+        type: "sint32",
         accessor: (arrow) => this.getArrowLineAttributes(arrow).positionsTextureOffset
       },
       instanceLineDistancesTextureOffset: {
         size: 1,
         transition: true,
-        type: GL.FLOAT,
+        type: "sint32",
         accessor: (arrow) => this.getArrowLineAttributes(arrow).distancesTextureOffset
       },
       instanceLinePointCount: {
         size: 1,
         transition: true,
-        type: GL.FLOAT,
+        type: "sint32",
         accessor: (arrow) => this.getArrowLineAttributes(arrow).pointCount
       },
       instanceLineParallelIndex: {
         size: 1,
         accessor: "getLineParallelIndex",
-        type: GL.FLOAT
+        type: "float32"
       },
       instanceLineAngles: {
         size: 3,
         accessor: "getLineAngles",
-        type: GL.FLOAT
+        type: "float32"
       },
       instanceProximityFactors: {
         size: 2,
         accessor: "getProximityFactors",
-        type: GL.FLOAT
+        type: "float32"
+      },
+      instanceDistanceBetweenLines: {
+        size: 1,
+        transition: true,
+        accessor: "getDistanceBetweenLines",
+        type: "float32",
+        defaultValue: 1e3
       }
     });
   }
@@ -2061,38 +2054,41 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
     super.finalizeState(context);
     this.state.stop = true;
   }
-  createTexture2D(gl, data, elementSize, format, dataFormat) {
+  createTexture2D(device, data, elementSize, format) {
     const start = performance.now();
-    const elementCount = data.length / elementSize;
-    const n = Math.ceil(Math.log2(elementCount) / 2);
-    const textureSize = 2 ** n;
     const { maxTextureSize } = this.state;
-    if (textureSize > maxTextureSize) {
-      throw new Error(`Texture size (${textureSize}) cannot be greater than ${maxTextureSize}`);
-    }
-    if (data.length < textureSize * textureSize * elementSize) {
-      const oldLength = data.length;
-      data.length = textureSize * textureSize * elementSize;
-      data.fill(0, oldLength, textureSize * textureSize * elementSize);
-    }
-    const texture2d = new core$1.Texture2D(gl, {
-      width: textureSize,
-      height: textureSize,
+    const elementCount = data.length / elementSize;
+    const expSum = Math.ceil(Math.log2(elementCount));
+    const widthExp = Math.ceil(expSum / 2);
+    const heightExp = expSum - widthExp;
+    const width = 2 ** widthExp;
+    const height = 2 ** heightExp;
+    if (height > maxTextureSize || width > maxTextureSize) {
+      throw new Error(`Texture size ${width}*${height} cannot be greater than ${maxTextureSize}`);
+    }
+    const newLength = width * height * elementSize;
+    const oldLength = data.length;
+    if (data.length < newLength) {
+      data.length = newLength;
+      data.fill(0, oldLength, newLength);
+    }
+    const texture2d = device.createTexture({
+      width,
+      height,
       format,
-      dataFormat,
-      type: GL.FLOAT,
+      type: constants$1.GL.FLOAT,
       data: new Float32Array(data),
       parameters: {
-        [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,
-        [GL.TEXTURE_MIN_FILTER]: GL.NEAREST,
-        [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
-        [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
+        [constants$1.GL.TEXTURE_MAG_FILTER]: constants$1.GL.NEAREST,
+        [constants$1.GL.TEXTURE_MIN_FILTER]: constants$1.GL.NEAREST,
+        [constants$1.GL.TEXTURE_WRAP_S]: constants$1.GL.CLAMP_TO_EDGE,
+        [constants$1.GL.TEXTURE_WRAP_T]: constants$1.GL.CLAMP_TO_EDGE
       },
       mipmaps: false
     });
     const stop = performance.now();
     console.info(
-      `Texture of ${elementCount} elements (${textureSize} * ${textureSize}) created in ${stop - start} ms`
+      `Texture of ${elementCount} elements of size ${elementSize} (${width} * ${height}) created in ${stop - start} ms`
     );
     return texture2d;
   }
@@ -2142,21 +2138,21 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
     var _a;
     const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getLinePositions);
     if (geometryChanged) {
-      const { gl } = this.context;
+      const { device } = this.context;
       const { linePositionsTextureData, lineDistancesTextureData, lineAttributes } = this.createTexturesStructure(props);
       const linePositionsTexture = this.createTexture2D(
-        gl,
+        device,
         linePositionsTextureData,
         2,
-        this.state.webgl2 ? GL.RG32F : GL.LUMINANCE_ALPHA,
-        this.state.webgl2 ? GL.RG : GL.LUMINANCE_ALPHA
+        "rg32float"
+        //GL.RG32F,
       );
       const lineDistancesTexture = this.createTexture2D(
-        gl,
+        device,
         lineDistancesTextureData,
         1,
-        this.state.webgl2 ? GL.R32F : GL.LUMINANCE,
-        this.state.webgl2 ? GL.RED : GL.LUMINANCE
+        "r32float"
+        //GL.R32F,
       );
       this.setState({
         linePositionsTexture,
@@ -2170,14 +2166,14 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
   }
   updateModel({ changeFlags }) {
     var _a;
-    if (changeFlags.extensionsChanged) {
-      const { gl } = this.context;
+    if (changeFlags.somethingChanged) {
+      const { device } = this.context;
       const { model } = this.state;
       if (model) {
-        model.delete();
+        model.destroy();
       }
       this.setState({
-        model: this._getModel(gl)
+        model: this._getModel(device)
       });
       (_a = this.getAttributeManager()) == null ? void 0 : _a.invalidateAll();
     }
@@ -2209,41 +2205,51 @@ const _ArrowLayer = class _ArrowLayer extends core.Layer {
   startAnimation() {
     window.requestAnimationFrame((timestamp) => this.animate(timestamp));
   }
-  // TODO find the full type for record values
-  draw({ uniforms }) {
-    var _a;
+  draw({ uniforms, renderPass }) {
     const { sizeMinPixels, sizeMaxPixels } = this.props;
-    const { linePositionsTexture, lineDistancesTexture, timestamp, webgl2 } = this.state;
-    (_a = this.state.model) == null ? void 0 : _a.setUniforms(uniforms).setUniforms({
-      sizeMinPixels,
-      sizeMaxPixels,
+    const {
+      model,
       linePositionsTexture,
       lineDistancesTexture,
-      // TODO we ask an opacity but we don't seem to set or used it?
+      timestamp
+      // maxTextureSize,
+    } = this.state;
+    model.setBindings({
       // @ts-expect-error TODO TS2339: Properties width and height does not exists on type Texture2D
-      linePositionsTextureSize: [linePositionsTexture == null ? void 0 : linePositionsTexture.width, linePositionsTexture == null ? void 0 : linePositionsTexture.height],
+      linePositionsTexture,
+      // @ts-expect-error TODO TS2339: Properties width and height does not exists on type Texture2D
+      lineDistancesTexture
+    });
+    model.setUniforms({
+      ...uniforms,
+      sizeMinPixels,
+      sizeMaxPixels,
+      // maxTextureSize,
+      // @ts-expect-error TODO TS2339: Properties width and height does not exists on type Texture2D
+      linePositionsTextureSize: [linePositionsTexture.width, linePositionsTexture.height],
+      // @ts-expect-error TODO TS2339: Properties width and height does not exists on type Texture2D
+      lineDistancesTextureSize: [lineDistancesTexture.width, lineDistancesTexture.height],
       // @ts-expect-error TODO TS2339: Properties width and height does not exists on type Texture2D
-      lineDistancesTextureSize: [lineDistancesTexture == null ? void 0 : lineDistancesTexture.width, lineDistancesTexture == null ? void 0 : lineDistancesTexture.height],
       timestamp,
-      webgl2,
-      distanceBetweenLines: this.props.getDistanceBetweenLines,
       maxParallelOffset: this.props.maxParallelOffset,
       minParallelOffset: this.props.minParallelOffset
-    }).draw();
+    });
+    model.draw(renderPass);
   }
-  // TODO Did you mean getModels?
-  _getModel(gl) {
-    return new core$1.Model(
-      gl,
+  _getModel(device) {
+    const positions = [-1, -1, 0, 0, 1, 0, 0, -0.6, 0, 1, -1, 0, 0, 1, 0, 0, -0.6, 0];
+    return new engine.Model(
+      device,
       Object.assign(this.getShaders(), {
         id: this.props.id,
-        geometry: new core$1.Geometry({
-          drawMode: GL.TRIANGLES,
+        bufferLayout: this.getAttributeManager().getBufferLayouts(),
+        geometry: new engine.Geometry({
+          topology: "triangle-list",
           vertexCount: 6,
           attributes: {
             positions: {
               size: 3,
-              value: new Float32Array([-1, -1, 0, 0, 1, 0, 0, -0.6, 0, 1, -1, 0, 0, 1, 0, 0, -0.6, 0])
+              value: new Float32Array(positions)
             }
           }
         }),
@@ -2498,10 +2504,10 @@ const _ForkLineLayer = class _ForkLineLayer extends layers.LineLayer {
     const shaders = super.getShaders();
     shaders.inject = {
       "vs:#decl": `
-attribute float instanceLineParallelIndex;
-attribute float instanceLineAngle;
-attribute float instanceOffsetStart;
-attribute float instanceProximityFactor;
+in float instanceLineParallelIndex;
+in float instanceLineAngle;
+in float instanceOffsetStart;
+in float instanceProximityFactor;
 uniform float distanceBetweenLines;
 uniform float maxParallelOffset;
 uniform float minParallelOffset;
@@ -2532,27 +2538,27 @@ uniform float minSubstationRadiusPixel;
     return shaders;
   }
   initializeState() {
+    var _a;
     super.initializeState();
-    const attributeManager = this.getAttributeManager();
-    attributeManager == null ? void 0 : attributeManager.addInstanced({
+    (_a = this.getAttributeManager()) == null ? void 0 : _a.addInstanced({
       instanceLineParallelIndex: {
         size: 1,
-        type: GL.FLOAT,
+        type: "float32",
         accessor: "getLineParallelIndex"
       },
       instanceLineAngle: {
         size: 1,
-        type: GL.FLOAT,
+        type: "float32",
         accessor: "getLineAngle"
       },
       instanceOffsetStart: {
         size: 1,
-        type: GL.FLOAT,
+        type: "float32",
         accessor: "getSubstationOffset"
       },
       instanceProximityFactor: {
         size: 1,
-        type: GL.FLOAT,
+        type: "float32",
         accessor: "getProximityFactor"
       }
     });
@@ -2608,7 +2614,7 @@ const _ParallelPathLayer = class _ParallelPathLayer extends layers.PathLayer {
 //       also has the downside that you can't update one attribute and reconstruct
 //       only its buffer, so it hurts performance a bit in this case.
 //       But this is a rare case for us (changing parameters) so it doesn't matter much.
-attribute vec4 instanceExtraAttributes;
+in vec4 instanceExtraAttributes;
 uniform float distanceBetweenLines;
 uniform float maxParallelOffset;
 uniform float minParallelOffset;
@@ -2656,12 +2662,11 @@ gl_Position += project_common_position_to_clipspace(trans) - project_uCenter;
       // too much instances variables need to compact some...
       instanceExtraAttributes: {
         size: 4,
-        type: GL.FLOAT,
+        type: "float32",
         accessor: "getExtraAttributes"
       }
     });
   }
-  // TODO find the full type for record values
   draw({ uniforms }) {
     super.draw({
       uniforms: {
@@ -3033,7 +3038,7 @@ const _LineLayer = class _LineLayer extends core.CompositeLayer {
             }
           );
           const arrowCount = Math.ceil(directLineDistance / DISTANCE_BETWEEN_ARROWS);
-          return [...new Array(arrowCount).keys()].map((index) => {
+          return Array.from({ length: arrowCount }, (_, index) => {
             return {
               distance: index / arrowCount,
               line
@@ -3246,10 +3251,13 @@ const _LineLayer = class _LineLayer extends core.CompositeLayer {
       const startFork = new ForkLineLayer(
         this.getSubLayerProps({
           id: "LineForkStart" + compositeData.nominalV,
+          data: compositeData.lines,
+          // @ts-expect-error TODO: manage undefined case
           getSourcePosition: (line) => line.origin,
+          // @ts-expect-error TODO: manage undefined case
           getTargetPosition: (line) => line.end,
+          // @ts-expect-error TODO: manage undefined case
           getSubstationOffset: (line) => line.substationIndexStart,
-          data: compositeData.lines,
           widthScale: 20,
           widthMinPixels: 1,
           widthMaxPixels: 2,
@@ -3259,6 +3267,7 @@ const _LineLayer = class _LineLayer extends core.CompositeLayer {
             getLineColor(line, nominalVoltageColor, this.props, this.state.linesConnection.get(line.id))
           ),
           getWidth: 2,
+          // @ts-expect-error TODO: manage undefined case
           getProximityFactor: (line) => line.proximityFactorStart,
           // @ts-expect-error TODO: manage undefined case
           getLineParallelIndex: (line) => line.parallelIndex,
@@ -3290,10 +3299,13 @@ const _LineLayer = class _LineLayer extends core.CompositeLayer {
       const endFork = new ForkLineLayer(
         this.getSubLayerProps({
           id: "LineForkEnd" + compositeData.nominalV,
+          data: compositeData.lines,
+          // @ts-expect-error TODO: manage undefined case
           getSourcePosition: (line) => line.end,
+          // @ts-expect-error TODO: manage undefined case
           getTargetPosition: (line) => line.origin,
+          // @ts-expect-error TODO: manage undefined case
           getSubstationOffset: (line) => line.substationIndexEnd,
-          data: compositeData.lines,
           widthScale: 20,
           widthMinPixels: 1,
           widthMaxPixels: 2,
@@ -3303,6 +3315,7 @@ const _LineLayer = class _LineLayer extends core.CompositeLayer {
             getLineColor(line, nominalVoltageColor, this.props, this.state.linesConnection.get(line.id))
           ),
           getWidth: 2,
+          // @ts-expect-error TODO: manage undefined case
           getProximityFactor: (line) => line.proximityFactorEnd,
           // @ts-expect-error TODO: manage undefined case
           getLineParallelIndex: (line) => -line.parallelIndex,
@@ -3630,7 +3643,7 @@ const _ScatterplotLayerExt = class _ScatterplotLayerExt extends layers.Scatterpl
       vs: shaders.vs.replace(", radiusMaxPixels", ", instanceRadiusMaxPixels"),
       // hack to replace the uniform variable to corresponding attribute
       inject: {
-        "vs:#decl": `attribute float instanceRadiusMaxPixels;
+        "vs:#decl": `in float instanceRadiusMaxPixels;
 `
       }
     });
@@ -3643,7 +3656,7 @@ const _ScatterplotLayerExt = class _ScatterplotLayerExt extends layers.Scatterpl
         size: 1,
         transition: true,
         accessor: "getRadiusMaxPixels",
-        type: GL.FLOAT,
+        type: "float32",
         defaultValue: 0
       }
     });
@@ -3684,9 +3697,7 @@ const _SubstationLayer = class _SubstationLayer extends core.CompositeLayer {
               substation.voltageLevels.map((voltageLevel) => voltageLevel.nominalV).sort((nominalVoltage1, nominalVoltage2) => nominalVoltage1 - nominalVoltage2)
             )
           ];
-          Array.from(voltageLevelsByNominalVoltage.entries()).forEach((e) => {
-            const nominalV = e[0];
-            const voltageLevels = e[1];
+          Array.from(voltageLevelsByNominalVoltage.entries()).forEach(([nominalV, voltageLevels]) => {
             let metaVoltageLevels = metaVoltageLevelsByNominalVoltage.get(nominalV);
             if (!metaVoltageLevels) {
               metaVoltageLevels = [];
@@ -4032,3 +4043,5 @@ exports.LineLayer = LineLayer;
 exports.MapEquipments = MapEquipments;
 exports.SubstationLayer = SubstationLayer;
 exports.getNominalVoltageColor = getNominalVoltageColor;
+exports.isMapLine = isMapLine;
+exports.isMapSubstation = isMapSubstation;