@dartcom/ui-kit 3.6.0 → 3.6.1

package/dist/index.cjs

@@ -44179,6 +44179,1224 @@ const LeafletLayer = () => {
     return null;
 };
 
+const getBuiltupAreaLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"MapAdminBuiltupArea"',
+    };
+    const layer = {
+        id: uuid(),
+        data,
+        draw: {
+            polygons: {
+                color: '#CFC8C8',
+            },
+        },
+    };
+    layers.push(layer);
+    return layers;
+};
+
+const getPointAddressLayers = (source) => {
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"PointAddress"',
+            minzoom: 15,
+        },
+        draw: {
+            text: {
+                interactive: true,
+                text_source: 'address',
+                font: {
+                    fill: 'black',
+                    size: '12px',
+                },
+            },
+        },
+    };
+    return [layer];
+};
+
+const text_source = `function() {
+  const { poi_name, cat_id } = feature;
+
+  switch (+cat_id) {
+    case 4100: {
+      const text = poi_name.replaceAll(/(Метро-|Станция-|МЦД-)/g, "");
+
+      return text;
+    }
+
+    default: {
+      return poi_name;
+    }
+  }
+}`;
+const catIds = [
+    3578, 4013, 4100, 5400, 5511, 5512, 5540, 5541, 5800, 5813, 5999, 6000, 7011,
+    7389, 7832, 7929, 7990, 8060, 8410, 9517, 9530, 9565, 9583, 9718, 9992,
+];
+
+const getDefaultPOI = (cat_id) => {
+    const defaultPOI = {};
+    switch (cat_id) {
+        case 4100: {
+            defaultPOI[`_${cat_id}-metro`] = {
+                filter: `function() {
+          const { poi_name, cat_id } = feature;
+
+          const isMetro = poi_name.startsWith('Метро-');
+          const isStation = poi_name.startsWith('Станция-');
+
+          const isCatId = +cat_id === ${cat_id};
+
+          const isFilter = isCatId && (isMetro || isStation);
+
+          return isFilter;
+        }`,
+                draw: {
+                    points: getPOITypeLayer(`POI_${cat_id}(metro)`),
+                },
+            };
+            defaultPOI[`_${cat_id}-diameter`] = {
+                filter: `function() {
+          const { cat_id, poi_name } = feature;
+
+          const isDiameter = poi_name.startsWith('МЦД-');
+
+          const isCatId = +cat_id === ${cat_id};
+
+          const isFilter = isCatId && isDiameter;
+
+          return isFilter;
+        }`,
+                draw: {
+                    points: getPOITypeLayer(`POI_${cat_id}(diameter)`),
+                },
+            };
+            break;
+        }
+        case 9530: {
+            defaultPOI[`_${cat_id}-mail`] = {
+                filter: `function() {
+          const { cat_id, poi_name = '' } = feature;
+
+          const isCatId = +cat_id === ${cat_id};
+
+          const isMail = poi_name.startsWith('Почта');
+
+          const isFilter = isCatId && isMail;
+
+          return isFilter;
+        }`,
+                draw: {
+                    points: getPOITypeLayer(`POI_${cat_id}(Mail)`),
+                },
+            };
+            defaultPOI[`_${cat_id}-delivery`] = {
+                filter: `function() {
+          const { cat_id, poi_name = '' } = feature;
+
+          const isCatId = +cat_id === ${cat_id};
+          
+          const isMail = poi_name.startsWith('Почта');
+
+          const isFilter = isCatId && !isMail;
+
+          return isFilter;
+        }`,
+                draw: {
+                    points: getPOITypeLayer(`POI_${cat_id}(Delivery)`),
+                },
+            };
+            break;
+        }
+        case 9992: {
+            const subcat = {
+                mosque: 1,
+                church: 2,
+                temple: 3,
+                davidStar: 4,
+                mortar: 6,
+            };
+            Object.entries(subcat).forEach(([subcat_name, subcat_id]) => {
+                defaultPOI[`_${cat_id}-${subcat_name}`] = {
+                    filter: `function() {
+            const { cat_id, subcat_id } = feature;
+
+            const isCatId = +cat_id === ${cat_id};
+            const isSubcatId = +subcat_id === ${subcat_id};
+
+            const isFilter = isCatId && isSubcatId;
+
+            return isFilter;
+          }`,
+                    draw: {
+                        points: getPOITypeLayer(`POI_${cat_id}(${subcat_name})`),
+                    },
+                };
+            });
+            break;
+        }
+        default: {
+            defaultPOI[`_${cat_id}`] = {
+                filter: `function {
+          const { cat_id } = feature;
+
+          const isFilter = +cat_id === ${cat_id};
+
+          return isFilter;
+        }`,
+                draw: {
+                    points: getPOITypeLayer(`POI_${cat_id}`),
+                },
+            };
+        }
+    }
+    return defaultPOI;
+};
+const getPOITypeLayer = (texture) => {
+    const typeLayer = {
+        texture,
+        sprite: 'base',
+        size: '20px',
+        placement: 'midpoint',
+    };
+    return typeLayer;
+};
+const sublayers = catIds.reduce((acc, catId) => ({
+    ...acc,
+    ...getDefaultPOI(catId),
+}), {});
+const getPOILayers = (source) => {
+    const layers = [];
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"POI"',
+        },
+        draw: {
+            points: {
+                text: {
+                    text_source,
+                    font: {
+                        fill: '#464544',
+                        size: '12px',
+                    },
+                },
+            },
+        },
+        sublayers,
+    };
+    layers.push(layer);
+    return layers;
+};
+
+const getCityPOILayers = (source) => {
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"CityPOI"',
+        },
+        filter: `function () {
+      const { capital_order8, capital_order2, capital_order1, poi_name, priority } = feature;
+
+      if ($zoom >= 9 && $zoom < 13) {
+        return priority < 8;
+      }
+
+      if ($zoom <= 11) {
+        return capital_order8 === 'Y';
+      }
+
+      if ($zoom >= 15) {
+        return capital_order2 !== 'Y';
+      }
+
+      return true;
+    }
+    `,
+        draw: {
+            text: {
+                text_source: 'poi_name',
+                priority: `function () {
+          const { priority } = feature;
+
+          if ($zoom <= 15) {
+            return priority;
+          }
+
+          return 1;
+        }
+        `,
+                font: {
+                    fill: 'black',
+                    size: `function() {
+            const { capital_order8 } = feature;
+
+            if (capital_order8 === 'Y') {
+              return '16px';
+            }
+
+            return '12px';
+          }`,
+                    weight: `function() {
+            const { capital_order2 } = feature;
+
+            if (capital_order2 === 'Y') {
+              return 'bold';
+            }
+
+            return 'normal';
+          }`,
+                    stroke: {
+                        color: 'white',
+                        width: '2px',
+                    },
+                },
+            },
+        },
+    };
+    return [layer];
+};
+
+const getOneWayLayers = (source) => {
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"OneWay"',
+        },
+        draw: {
+            points: {
+                texture: 'arrow',
+                sprite: 'base',
+                angle: `function() {
+          const { bearing } = feature;
+          
+          return bearing;
+        }
+        `,
+            },
+        },
+    };
+    return [layer];
+};
+
+var ConditionTypes;
+(function (ConditionTypes) {
+    ConditionTypes["traffic_signal"] = "traffic_signal";
+    ConditionTypes["pedestrian_crossing"] = "pedestrian_crossing";
+    ConditionTypes["physical"] = "physical";
+    ConditionTypes["gate"] = "gate";
+})(ConditionTypes || (ConditionTypes = {}));
+
+const getConditionLayers = (source) => {
+    const sublayers = {};
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"Conditions"',
+        },
+    };
+    Object.values(ConditionTypes).forEach((conditionType) => {
+        sublayers[`_${conditionType}`] = {
+            filter: `function() {
+        const { type } = feature;
+
+        const isShow = type === '${conditionType}';
+
+        return isShow;
+      }`,
+            draw: {
+                points: {
+                    texture: conditionType,
+                    sprite: 'base',
+                    placement: 'midpoint',
+                },
+            },
+        };
+    });
+    layer.sublayers = sublayers;
+    return [layer];
+};
+
+const getRailroadLayers = (source) => {
+    const layer = '"MapRailroadLink"';
+    const layers = [];
+    const data = {
+        source,
+        layer,
+    };
+    const frontLayer = {
+        id: uuid(),
+        data: {
+            source,
+            layer,
+        },
+        draw: {
+            lines: {
+                width: 5,
+                dash: [2, 1],
+                color: '#5C5F5F',
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    const backLayer = {
+        id: uuid(),
+        data,
+        draw: {
+            lines: {
+                width: 6,
+                color: '#A3A8A',
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    layers.push(backLayer, frontLayer);
+    return layers;
+};
+
+const getWaterAreaLayers = (source) => {
+    const layers = [];
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapWaterArea"',
+        },
+        draw: {
+            polygons: {
+                color: '#7DBEE4',
+            },
+            lines: {
+                color: '#7DBEE4',
+                width: 20,
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    const waterAreaLabelLayer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapWaterAreaLabel"',
+        },
+        filter: `function() {
+      const { display_class } = feature;
+
+      if ($zoom >= 14) {
+        return true;
+      } else {
+        return display_class <= 4;
+      }
+    }`,
+        draw: {
+            text: {
+                text_source: 'name',
+                font: {
+                    fill: '#0A80C4',
+                    size: '14px',
+                    stroke: { color: 'white', width: '3px' },
+                },
+            },
+        },
+    };
+    const waterLakeLabelLayer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapWaterLakeLabel"',
+        },
+        filter: `function() {
+      const { display_class } = feature;
+
+      if ($zoom >= 14) {
+        return true;
+      } else {
+        return display_class <= 4;
+      }
+    }`,
+        draw: {
+            text: {
+                text_source: 'name',
+                font: {
+                    fill: '#0A80C4',
+                    size: '14px',
+                    stroke: { color: 'white', width: '3px' },
+                },
+            },
+        },
+    };
+    layers.push(layer, waterAreaLabelLayer, waterLakeLabelLayer);
+    return layers;
+};
+
+const getWaterLinkLayers = (source) => {
+    const sublayers = {};
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapWaterLink"',
+        },
+    };
+    sublayers.geometry = {
+        draw: {
+            lines: {
+                color: '#7DBEE4',
+                width: 5,
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    sublayers.text = {
+        filter: `function() {
+      return $zoom >= 10;
+    }`,
+        draw: {
+            text: {
+                text_source: 'name',
+                font: {
+                    fill: '#0A80C4',
+                    size: '14px',
+                    stroke: { color: 'white', width: '3px' },
+                },
+            },
+        },
+    };
+    layer.sublayers = sublayers;
+    return [layer];
+};
+
+const getOceanAreaLayers = (source) => {
+    const geometryLayer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapOceanArea"',
+        },
+        draw: {
+            polygons: {
+                color: '#7DBEE4',
+            },
+        },
+    };
+    const textLayer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapOceanAreaLabel"',
+        },
+        draw: {
+            text: {
+                text_source: 'name',
+                font: {
+                    fill: '#0A80C4',
+                    size: '18px',
+                    stroke: { color: 'white', width: '3px' },
+                },
+            },
+        },
+    };
+    return [geometryLayer, textLayer];
+};
+
+const getLanduseAreaLayers = (source) => {
+    const layers = [];
+    switch (source) {
+        case exports.TangramSourceNames.NATURE_TILE: {
+            const geometryLayer = {
+                id: uuid(),
+                data: {
+                    source,
+                    layer: '"MapNatureForest"',
+                },
+                draw: {
+                    polygons: {
+                        interactive: true,
+                        color: `function() {
+              const { feature_type } = feature;
+
+              switch (feature_type) {
+                case '900202': {
+                  return '#96BE7D';
+                }
+
+                default : {
+                  return null;
+                }
+              }
+            }`,
+                    },
+                },
+            };
+            layers.push(geometryLayer);
+            break;
+        }
+        default: {
+            const geometryLayer = {
+                id: uuid(),
+                data: {
+                    source,
+                    layer: '"MapLanduseArea"',
+                },
+                draw: {
+                    polygons: {
+                        interactive: true,
+                        color: `function() {
+              const { feature_type } = feature;
+
+              switch (feature_type) {
+                case '509998': {
+                  return '#ECD175';
+                }
+
+                case '600102':
+                case '900140': {
+                  return '#3E9A8C';
+                }
+
+                case '900202':
+                case '900130':
+                case '900150':
+                case '900103': {
+                  return '#96BE7D';
+                }
+
+                case '9997010': {
+                  return null;
+                }
+              }
+            }`,
+                        order: `function() {
+              const { feature_type } = feature;
+
+              switch(feature_type) {
+                case '900150':
+                case '900130':
+                case '509998': {
+                  return 300;
+                }
+
+                default: {
+                  return 299;
+                }
+              }
+            }`,
+                    },
+                },
+            };
+            const labelLayer = {
+                id: uuid(),
+                data: {
+                    source,
+                    layer: '"MapLanduseAreaLabel"',
+                },
+                filter: `function() {
+          return $zoom >= 15;
+        }`,
+                draw: {
+                    text: {
+                        text_source: 'name',
+                        font: {
+                            size: '13px',
+                            fill: `function() {
+                const { feature_type } = feature;
+
+                switch(feature_type) {
+                  case '509998': {
+                    return '#CD7F32';
+                  }
+
+                  default: {
+                    return '#00541F';
+                  }
+                }
+              }`,
+                            stroke: { color: 'white', width: '3px' },
+                        },
+                    },
+                },
+            };
+            layers.push(geometryLayer, labelLayer);
+        }
+    }
+    return layers;
+};
+
+const getBuildingLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"MapBuildingECArea"',
+        minzoom: 15,
+    };
+    const layer = {
+        id: uuid(),
+        data,
+        extruded: {
+            draw: {
+                polygons: {
+                    interactive: true,
+                    style: 'buildings',
+                    extrude: `function() {
+            return $zoom >= 17;
+          }`,
+                },
+            },
+        },
+        draw: {
+            polygons: {
+                color: '#DDB07B',
+                height: { property: 'height' },
+            },
+            lines: {
+                color: '#DB933F',
+                width: '2px',
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    layers.push(layer);
+    return layers;
+};
+
+const getFacilityAreaLayers = (source) => {
+    const layers = [];
+    const geometryLayer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapFacilityArea"',
+        },
+        draw: {
+            polygons: {
+                color: `function() {
+          const { feature_type } = feature;
+
+          switch (feature_type) {
+            case '2000408': {
+              return '#DBBAC4';
+            }
+
+            case '1900403': {
+              return '#B6C3C7';
+            }
+
+            case '1907403': {
+              return '#A3B9C0';
+            }
+
+            case '2000123': {
+              return '#E4BA7D';
+            }
+
+            case '2000124': {
+              return '#BFE6E3';
+            }
+
+            case '2000200': {
+              return '#A0A9A8';
+            }
+
+            case '2000403': {
+              return '#AF7136';
+            }
+
+            case '2000420': {
+              return '#89AC76';
+            }
+
+            case '2000457': {
+              return '#9494C0';
+            }
+
+            default: {
+              return '#E1D4D4';
+            }
+          }
+        }`,
+                order: `function() {
+          const { feature_type } = feature;
+
+          switch (feature_type) {
+            case '1907403': {
+              return 301;
+            }
+
+            default: {
+              return 300;
+            }
+          }
+        }`,
+            },
+            lines: {
+                color: '#857F7F',
+                width: '2px',
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    const labelLayer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapFacilityAreaLabel"',
+        },
+        draw: {
+            text: {
+                text_source: 'name',
+                font: {
+                    fill: `function() {
+            const { feature_type } = feature;
+
+            switch(feature_type) {
+              case '1900403':
+              case '1907403': {
+                return '#256D7B';
+              }
+
+               case '2000420':
+              case '2000460':
+              case '2000123': {
+                return '#00541F';
+              }
+
+               case '2000408': {
+                return '#5E2129';
+              }
+
+               case '2000124': {
+                return '#3E5F8A';
+              }
+
+               case '2000200': {
+                return '#464451';
+              }
+
+               case '2000403': {
+                return '#B03F35';
+              }
+
+               case '2000457': {
+                return '#6A5ACD';
+              }
+
+               case '1700215':
+              case '900159':
+              case '900158': {
+                return '#474A51';
+              }
+
+               default: {
+                return black;
+              }
+            }
+          }`,
+                    size: '12px',
+                    stroke: {
+                        color: 'white',
+                        width: '3px',
+                    },
+                },
+            },
+        },
+    };
+    layers.push(geometryLayer, labelLayer);
+    return layers;
+};
+
+const adminAreaLayerName = '"MapAdminArea"';
+
+const getAdminAreaLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: adminAreaLayerName,
+    };
+    const layer = {
+        id: uuid(),
+        data,
+        draw: {
+            polygons: {
+                color: '#D3D2CF',
+            },
+        },
+    };
+    const borderRegionLayer = {
+        id: uuid(),
+        data,
+        filter: `function() {
+      const { type } = feature;
+
+      const isFilter = type === 'R';
+
+      return isFilter;
+    }`,
+        draw: {
+            lines: {
+                color: '#696969',
+                width: '1px',
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    const borderDistrictLayer = {
+        id: uuid(),
+        data,
+        filter: `function() {
+      const { type } = feature;
+
+      const isFilter = type === 'D' && $zoom >= 12;
+
+      return isFilter;
+    }`,
+        draw: {
+            lines: {
+                color: '#696969',
+                dash: [4, 7],
+                width: '1px',
+                cap: 'round',
+                join: 'round',
+            },
+        },
+    };
+    layers.push(layer, borderRegionLayer, borderDistrictLayer);
+    return layers;
+};
+
+const getNatureFieldLayers = (source) => {
+    const layer = {
+        id: uuid(),
+        data: {
+            source,
+            layer: '"MapNatureField"',
+        },
+        draw: {
+            polygons: {
+                interactive: true,
+                color: '#EBEEC7',
+            },
+        },
+    };
+    return [layer];
+};
+
+const linkLayerName = '"Link"';
+const zLvlOrders = [
+    '2.0',
+    '1.5',
+    '1.0',
+    '0.7',
+    '0.5',
+    '0.3',
+    '0.0',
+    '-0.3',
+    '-0.5',
+    '-0.1',
+];
+const functionInterval = [[1, 2], [3, 4], [5]];
+const colorFunction = `function() {
+  const { functional_class, tunnel, tollway } = feature;
+
+  const alpha = tunnel ? 0.89 : 1;
+
+  const getRGB = (hex, alpha) => {
+    const r = +(parseInt(hex.slice(1, 3), 16) / 255).toFixed(2);
+    const g = +(parseInt(hex.slice(3, 5), 16) / 255).toFixed(2);
+    const b = +(parseInt(hex.slice(5, 7), 16) / 255).toFixed(2);
+
+    return [r, g, b, alpha];
+  }
+
+  if (tollway) {
+    return '#D72740';
+  }
+
+  switch (functional_class) {
+    case 1:
+    case 2: {
+      const color = getRGB('#D1747F', alpha);
+
+      return color;
+    }
+
+    case 3:
+    case 4: {
+      const color = getRGB('#B1A7AA', alpha);
+
+      return color;
+    }
+
+    case 5: {
+      const color = getRGB('#D5CEC3', alpha);
+
+      return color;
+    }
+  }
+}`;
+const widthFunction = `function() {
+  const { functional_class, road_number } = feature;
+
+  const getScale = () => {
+    if ($zoom <= 15 && $zoom >= 14) { return 7; }
+
+    if ($zoom <= 13 && $zoom >= 12) { return 9; }
+
+    if ($zoom <= 5) { return 400; }
+
+    if ($zoom <= 7) { return 200; }
+
+    if ($zoom < 12) { return 50; }
+
+    return 1;
+  }
+
+  const scale = getScale();
+
+  switch(functional_class) {
+    case 1:
+    case 2: {
+      return 8 * scale;
+    }
+
+    case 3:
+    case 4: {
+      return 7 * scale;
+    }
+
+    case 5: {
+      if (Boolean(road_number)) {
+        return 7 * scale;
+      }
+
+      return 6;
+    }
+  }
+}`;
+const outlineColorFunction = `function() {
+  const { functional_class, access_id, tollway } = feature;
+
+  if (tollway) {
+    return '#B9263B';
+  }
+
+  switch(functional_class) {
+    case 5: {
+      return '#989898';
+    }
+
+    case 3:
+    case 4: {
+      return '#8F6E78';
+    }
+
+    case 1:
+    case 2: {
+      return '#9A414B';
+    }
+  }
+}`;
+const outlineWidthFunction = `function() {
+  const { functional_class, access_id } = feature;
+
+  switch(functional_class) {
+    case 5: {
+      switch (access_id) {
+        case 32: {
+          return 0;
+        }
+
+        default: {
+          return 1;
+        }
+      }
+    }
+
+    default: {
+      return 1;
+    }
+  }
+}`;
+
+const getLinkLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: linkLayerName,
+    };
+    const roadNumberLayer = {
+        id: uuid(),
+        data,
+        draw: {
+            text: {
+                text_source: 'road_number',
+                font: {
+                    fill: '#181bff',
+                    size: '16px',
+                    weight: 'bold',
+                    underline: true,
+                    background: {
+                        color: 'black',
+                    },
+                },
+            },
+        },
+    };
+    layers.push(roadNumberLayer);
+    zLvlOrders.forEach((zLvl) => {
+        const filter = `function() {
+      const { z_lvl = '0.0' } = feature;
+
+      const isFilter = z_lvl === '${zLvl}';
+
+      return isFilter;
+    }`;
+        const text = {
+            text_source: 'street_name',
+            font: {
+                fill: 'black',
+                size: '14px',
+                stroke: { color: 'white', width: '3px' },
+            },
+        };
+        const getBaseLayerDraw = () => ({
+            text,
+            lines: {
+                color: colorFunction,
+                width: widthFunction,
+                cap: 'round',
+                join: 'round',
+            },
+        });
+        const getBorderLayerDraw = () => ({
+            lines: {
+                color: colorFunction,
+                width: widthFunction,
+                cap: 'round',
+                join: 'round',
+                outline: {
+                    color: outlineColorFunction,
+                    width: outlineWidthFunction,
+                },
+            },
+        });
+        switch (zLvl) {
+            case '0.0': {
+                functionInterval.forEach((functionClasses) => {
+                    functionClasses.forEach((functionClass) => {
+                        const baseLayer = {
+                            id: uuid(),
+                            data,
+                            filter: `function() {
+                const { functional_class, z_lvl = '0.0' } = feature;
+
+                const isFilter = z_lvl === '${zLvl}' && functional_class === ${functionClass};
+
+                return isFilter;
+              }`,
+                            draw: getBaseLayerDraw(),
+                            sublayers: {
+                                construction: {
+                                    filter: `function() {
+                    return global.links.getIsConstruction(feature);
+                  }`,
+                                    draw: {
+                                        lines: {
+                                            width: 3,
+                                            color: '#9AA096',
+                                            dash: [2, 1],
+                                        },
+                                    },
+                                },
+                                functionalClassAccessId32: {
+                                    filter: `function() {
+                    return global.links.getIsFunctionalClass(feature);
+                  }`,
+                                    draw: {
+                                        lines: {
+                                            width: 2,
+                                            color: '#9AA096',
+                                            dash: [2, 1],
+                                        },
+                                    },
+                                },
+                                lowMobility: {
+                                    filter: `function() {
+                    return global.links.getIsLowMobility(feature);
+                  }`,
+                                    draw: {
+                                        lines: {
+                                            width: 4,
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        const borderLayer = {
+                            id: uuid(),
+                            data,
+                            filter: `function() {
+                const { functional_class, z_lvl = '0.0' } = feature;
+
+                const isFilter = z_lvl === '${zLvl}' && functional_class === ${functionClass} && !global.links.getIsConstruction(feature) && !global.links.getIsFunctionalClass(feature);
+
+                return isFilter;
+              }`,
+                            draw: getBorderLayerDraw(),
+                            sublayers: {
+                                lowMobility: {
+                                    filter: `function() {
+                    return global.links.getIsLowMobility(feature);
+                  }`,
+                                    draw: {
+                                        lines: {
+                                            width: 4,
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        layers.push(baseLayer, borderLayer);
+                    });
+                });
+                break;
+            }
+            default: {
+                const baseLayer = {
+                    id: uuid(),
+                    data,
+                    filter,
+                    draw: getBaseLayerDraw(),
+                };
+                const borderLayer = {
+                    id: uuid(),
+                    data,
+                    filter,
+                    draw: getBorderLayerDraw(),
+                };
+                layers.push(baseLayer, borderLayer);
+            }
+        }
+    });
+    return layers;
+};
+
 // define() gets called for each chunk generated by the first Rollup pass.
             // The order the chunks are called in is controlled by the imports in bundle.js:
             //
@@ -44246,12 +45464,32 @@ exports.NoData = NoData;
 exports.Select = CustomSelect;
 exports._backendUrl = _backendUrl;
 exports._testApiKeys = _testApiKeys;
+exports.catIds = catIds;
+exports.getAdminAreaLayers = getAdminAreaLayers;
+exports.getBuildingLayers = getBuildingLayers;
+exports.getBuiltupAreaLayers = getBuiltupAreaLayers;
+exports.getCityPOILayers = getCityPOILayers;
+exports.getConditionLayers = getConditionLayers;
+exports.getDefaultPOI = getDefaultPOI;
+exports.getFacilityAreaLayers = getFacilityAreaLayers;
+exports.getLanduseAreaLayers = getLanduseAreaLayers;
 exports.getLaneMarkingLineLayers = getLaneMarkingLineLayers;
 exports.getLaneMarkingPointLayers = getLaneMarkingPointLayers;
 exports.getLaneMarkingPolyLayers = getLaneMarkingPolyLayers;
+exports.getLinkLayers = getLinkLayers;
+exports.getNatureFieldLayers = getNatureFieldLayers;
+exports.getOceanAreaLayers = getOceanAreaLayers;
+exports.getOneWayLayers = getOneWayLayers;
+exports.getPOILayers = getPOILayers;
+exports.getPOITypeLayer = getPOITypeLayer;
 exports.getParkingLineLayers = getParkingLineLayers;
+exports.getPointAddressLayers = getPointAddressLayers;
+exports.getRailroadLayers = getRailroadLayers;
 exports.getRoadPolyLayers = getRoadPolyLayers;
+exports.getWaterAreaLayers = getWaterAreaLayers;
+exports.getWaterLinkLayers = getWaterLinkLayers;
 exports.sourceUrl = sourceUrl;
+exports.text_source = text_source;
 exports.tile_size = tile_size;
 exports.useFormContext = useFormContext;
 exports.useGetLeafletLayer = useGetLeafletLayer;