@dartcom/ui-kit 3.5.3 → 3.6.1

package/dist/index.cjs

@@ -43373,6 +43373,8 @@ const {
   mergeConfig
 } = axios;
 
+const _backendUrl = 'https://dalganmap.ru/api';
+
 class ApiService {
     client;
     constructor(baseURL) {
@@ -43408,7 +43410,7 @@ class ApiService {
         return response.data;
     }
 }
-const apiService = new ApiService('https://dalganmap.ru/api');
+const apiService = new ApiService(_backendUrl);
 
 class GlobalConfig {
     static _instance = null;
@@ -43473,6 +43475,411 @@ const _testApiKeys = {
     invalid: 'abcdefghijklmnopqrstuvwxyz0123456789',
 };
 
+/**
+A function that returns a universally unique identifier (uuid).  
+example: 1b83fd69-abe7-468c-bea1-306a8aa1c81d
+@returns `string` : 32 character uuid (see example)
+*/
+
+var uuid_1;
+var hasRequiredUuid;
+
+function requireUuid () {
+	if (hasRequiredUuid) return uuid_1;
+	hasRequiredUuid = 1;
+	function uuid() {
+		const hashTable = [
+			"a",
+			"b",
+			"c",
+			"d",
+			"e",
+			"f",
+			"0",
+			"1",
+			"2",
+			"3",
+			"4",
+			"5",
+			"6",
+			"7",
+			"8",
+			"9",
+		];
+		let uuid = [];
+		for (let i = 0; i < 36; i++) {
+			if (i === 8 || i === 13 || i === 18 || i === 23) {
+				uuid[i] = "-";
+			} else {
+				uuid[i] = hashTable[Math.ceil(Math.random() * hashTable.length - 1)];
+			}
+		}
+		return uuid.join("");
+	}
+
+	uuid_1 = uuid;
+	return uuid_1;
+}
+
+var uuidExports = requireUuid();
+var uuid = /*@__PURE__*/getDefaultExportFromCjs(uuidExports);
+
+exports.API_METHODS = void 0;
+(function (API_METHODS) {
+    API_METHODS["GET"] = "GET";
+    API_METHODS["DELETE"] = "DELETE";
+    API_METHODS["PUT"] = "PUT";
+    API_METHODS["POST"] = "POST";
+})(exports.API_METHODS || (exports.API_METHODS = {}));
+
+exports.PanelsNames = void 0;
+(function (PanelsNames) {
+    PanelsNames["TOP_RIGHT"] = "top-right";
+    PanelsNames["BOTTOM_RIGHT"] = "bottom-right";
+    PanelsNames["BOTTOM_LEFT"] = "bottom-left";
+    PanelsNames["TOP_LEFT"] = "top-left";
+})(exports.PanelsNames || (exports.PanelsNames = {}));
+
+exports.TangramSourceNames = void 0;
+(function (TangramSourceNames) {
+    TangramSourceNames["TILE"] = "tile";
+    TangramSourceNames["NATURE_TILE"] = "nature_tile";
+    TangramSourceNames["MSK"] = "msk";
+})(exports.TangramSourceNames || (exports.TangramSourceNames = {}));
+
+const tile_size = 256;
+const sourceUrl = {
+    [exports.TangramSourceNames.TILE]: `${_backendUrl}/tiles/get_tile/{z}/{x}/{y}.mvt`,
+    [exports.TangramSourceNames.NATURE_TILE]: `${_backendUrl}/tiles/get_nature_tile/{z}/{x}/{y}.mvt`,
+    [exports.TangramSourceNames.MSK]: 'http://89.108.118.23:3070/tiles/get_tile/{z}/{x}/{y}.mvt',
+};
+const getRoadPolyLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"RoadPoly"',
+    };
+    const roadLayer = {
+        id: uuid(),
+        data,
+        filter: `function() {
+      const { type } = feature;
+
+      const isFilter = type === 'Road';
+
+      return isFilter;
+    }`,
+        draw: {
+            polygons: {
+                color: '#B3BDCF',
+            },
+        },
+    };
+    const tramLayer = {
+        id: uuid(),
+        data,
+        filter: `function() {
+      const { type } = feature;
+
+      const isFilter = type === 'Tram';
+
+      return isFilter;
+    }`,
+        draw: {
+            polygons: {
+                color: '#ADA8A8',
+            },
+        },
+    };
+    const curbLayer = {
+        id: uuid(),
+        data,
+        filter: `function() {
+      const { type } = feature;
+
+      const isFilter = type === 'Curb';
+
+      return isFilter;
+    }`,
+        draw: {
+            polygons: {
+                color: '#D2D9E6',
+            },
+        },
+    };
+    const bridgeLayer = {
+        id: uuid(),
+        data,
+        filter: `function() {
+      const { type } = feature;
+
+      const isFilter = type === 'Bridge';
+
+      return isFilter;
+    }`,
+        draw: {
+            polygons: {
+                color: '#E1DFDD',
+            },
+        },
+    };
+    layers.push(roadLayer, tramLayer, curbLayer, bridgeLayer);
+    return layers;
+};
+const getLaneMarkingPolyLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"LaneMarkingPoly"',
+    };
+    const layer__1_26 = {
+        id: uuid(),
+        data,
+        filter: `function() {
+      const { poly_number } = feature;
+
+      const isFilter = poly_number === '1.26';
+
+      return isFilter;
+    }`,
+        draw: {
+            styles: {
+                'diagonal-grid': {
+                    color: 'yellow',
+                },
+            },
+        },
+    };
+    layers.push(layer__1_26);
+    return layers;
+};
+const getLaneMarkingLineLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"LaneMarkingLine"',
+    };
+    const layer = {
+        id: uuid(),
+        data,
+        sublayers: {
+            '1.1': {
+                filter: `function () {
+          const { lane_number } = feature;
+
+          const isFilter = lane_number === '1.1';
+
+          return isFilter;
+        }`,
+                draw: {
+                    lines: {
+                        color: 'white',
+                        width: 1,
+                    },
+                },
+            },
+            '1.6': {
+                filter: `function () {
+          const { lane_number } = feature;
+
+          const isFilter = lane_number === '1.6';
+
+          return isFilter;
+        }`,
+                draw: {
+                    lines: {
+                        color: 'white',
+                        width: 1,
+                        dash: [5, 5],
+                    },
+                },
+            },
+            '1.7': {
+                filter: `function () {
+          const { lane_number } = feature;
+
+          const isFilter = lane_number === '1.7';
+
+          return isFilter;
+        }`,
+                draw: {
+                    lines: {
+                        color: 'white',
+                        width: 0.5,
+                        dash: [4, 10],
+                    },
+                },
+            },
+            '1.7-blue': {
+                filter: `function () {
+          const { lane_number } = feature;
+
+          const isFilter = lane_number === '1.7blue';
+
+          return isFilter;
+        }`,
+                draw: {
+                    lines: {
+                        color: 'blue',
+                        width: 0.5,
+                        dash: [4, 10],
+                    },
+                },
+            },
+            '1.14.3': {
+                filter: `function () {
+          const { lane_number } = feature;
+
+          const isFilter = lane_number === '1.14.3';
+
+          return isFilter;
+        }`,
+                draw: {
+                    lines: {
+                        color: 'white',
+                        width: 0.5,
+                        dash: [4, 10],
+                    },
+                },
+            },
+            '1.12': {
+                filter: `function () {
+          const { lane_number } = feature;
+
+          const isFilter = lane_number === '1.12';
+
+          return isFilter;
+        }`,
+                draw: {
+                    lines: {
+                        color: 'white',
+                        width: 2,
+                    },
+                },
+            },
+        },
+    };
+    layers.push(layer);
+    return layers;
+};
+const getLaneMarkingPointLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"LaneMarkingPoint"',
+    };
+    const layer = {
+        id: uuid(),
+        data,
+        draw: {
+            points: {
+                texture: 'lane-marking',
+                sprite: 'base',
+                angle: `function() {
+          const { angle } = feature;
+          
+          return angle;
+        }
+        `,
+                placement: 'midpoint',
+            },
+        },
+    };
+    layers.push(layer);
+    return layers;
+};
+const getParkingLineLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"ParkingLine"',
+    };
+    const layer = {
+        id: uuid(),
+        data,
+        draw: {
+            lines: {
+                color: 'white',
+                width: 1,
+            },
+        },
+    };
+    layers.push(layer);
+    return layers;
+};
+
+const getLayerName = ({ id, data: { source, layer }, }) => {
+    const layerName = `${id}-${source}-${layer}`;
+    return layerName;
+};
+const setLayerOrder = ({ layer, order, }) => {
+    const cloneLayer = structuredClone(layer);
+    const { draw, sublayers } = cloneLayer;
+    if (draw) {
+        const { points, lines, polygons, text, styles } = draw;
+        if (points) {
+            draw.points = {
+                ...structuredClone(points),
+                order,
+            };
+        }
+        if (lines) {
+            draw.lines = {
+                ...structuredClone(lines),
+                order,
+            };
+        }
+        if (polygons) {
+            draw.polygons = {
+                ...structuredClone(polygons),
+                order,
+            };
+        }
+        if (text) {
+            draw.text = {
+                ...structuredClone(text),
+                order,
+            };
+        }
+        if (styles) {
+            draw.styles = Object.entries(styles).reduce((accum, [name, style]) => ({
+                ...accum,
+                [name]: {
+                    ...structuredClone(style),
+                    order,
+                },
+            }), {});
+        }
+        cloneLayer.draw = structuredClone(draw);
+    }
+    if (sublayers) {
+        Object.entries(sublayers).forEach(([name, sublayer]) => {
+            if (sublayer) {
+                const { draw } = sublayer;
+                if (draw) {
+                    const { points, lines, polygons } = draw;
+                    if (points) {
+                        points.order = order;
+                        draw.points = points;
+                    }
+                    if (lines) {
+                        lines.order = order;
+                        draw.lines = lines;
+                    }
+                    if (polygons) {
+                        polygons.order = order;
+                        draw.polygons = polygons;
+                    }
+                    sublayer.draw = structuredClone(draw);
+                }
+                sublayers[name] = structuredClone(sublayer);
+            }
+        });
+        cloneLayer.sublayers = structuredClone(sublayers);
+    }
+    return cloneLayer;
+};
+
 const useGetLeafletLayer = () => {
     const { instance: { isValidApiKey }, } = GlobalConfig;
     const [layer, setLayer] = React__namespace.useState(null);
@@ -43490,6 +43897,141 @@ const useGetLeafletLayer = () => {
             }
         });
     };
+    const addSource = React__namespace.useCallback((sourceConfig) => {
+        if (!scene) {
+            console.warn('Scene не инициализирована');
+            return;
+        }
+        if (!config) {
+            console.warn('Config не инициализирована');
+            return;
+        }
+        const { name } = sourceConfig;
+        config.sources[name] = structuredClone(sourceConfig);
+        scene.updateConfig({ rebuild: true });
+        return getSources();
+    }, [scene, config]);
+    const getSource = React__namespace.useCallback((sourceName) => {
+        if (!config) {
+            console.warn('Config не инициализирована');
+            return;
+        }
+        return structuredClone(config.sources[sourceName]);
+    }, [config]);
+    const updateSource = React__namespace.useCallback((sourceName, newUrl) => {
+        if (!scene) {
+            console.warn('Scene не инициализирована');
+            return;
+        }
+        if (!config) {
+            console.warn('Config не инициализирована');
+            return;
+        }
+        config.sources[sourceName].url = newUrl;
+        scene.updateConfig({ rebuild: true });
+        return getSources();
+    }, [config, scene]);
+    const addLayer = React__namespace.useCallback((layer) => {
+        if (!scene) {
+            console.warn('Scene не инициализирован');
+            return;
+        }
+        if (!config) {
+            console.warn('Config не инициализирован');
+            return;
+        }
+        const order = getLayers().length + 1;
+        const layerWithOrder = setLayerOrder({
+            layer,
+            order,
+        });
+        const layerName = getLayerName(layerWithOrder);
+        const { sublayers = {}, draw } = layerWithOrder;
+        if (draw) {
+            const { styles = {} } = draw;
+            if (styles) {
+                layerWithOrder.draw = {
+                    ...structuredClone(draw),
+                    ...structuredClone(styles),
+                };
+            }
+        }
+        config.layers[layerName] = {
+            ...structuredClone(layerWithOrder),
+            ...structuredClone(sublayers),
+        };
+        scene.updateConfig({ rebuild: true });
+        return getLayers();
+    }, [config, scene]);
+    const removeLayer = React__namespace.useCallback((layer) => {
+        if (!scene) {
+            console.warn('Scene не инициализирован');
+            return;
+        }
+        if (!config) {
+            console.warn('Config не инициализирован');
+            return;
+        }
+        const layerName = getLayerName(layer);
+        if (config.layers[layerName]) {
+            delete config.layers[layerName];
+        }
+        scene.updateConfig({ rebuild: true });
+        return getLayers();
+    }, [config, scene]);
+    const addStyle = React__namespace.useCallback(({ name, style }) => {
+        if (!scene) {
+            console.warn('Scene не инициализирована');
+            return;
+        }
+        if (!config) {
+            console.warn('Config не инициализирована');
+            return;
+        }
+        config.styles[name] = structuredClone(style);
+        scene.updateConfig({ rebuild: true });
+    }, [config, scene]);
+    const getLayerVisibility = React__namespace.useCallback((layer) => {
+        if (!config) {
+            console.warn('Config не инициализирована');
+            return;
+        }
+        const layerName = getLayerName(layer);
+        const { visible: layerVisibility } = config.layers[layerName];
+        return layerVisibility;
+    }, [config]);
+    const toggleLayerVisibility = React__namespace.useCallback(({ layer, visible }) => {
+        if (!scene) {
+            console.warn('Scene не инициализирована');
+            return;
+        }
+        if (!config) {
+            console.warn('Config не инициализирована');
+            return;
+        }
+        const layerName = getLayerName(layer);
+        config.layers[layerName].visible = visible;
+        scene.updateConfig();
+        return getLayerVisibility(layer);
+    }, [config, scene]);
+    const getLayers = React__namespace.useCallback(() => {
+        if (!config)
+            return [];
+        const { layers } = config;
+        return Object.keys(layers);
+    }, [config]);
+    const removeLayers = React__namespace.useCallback(() => {
+        if (!config)
+            return [];
+        const { layers } = config;
+        Object.values(layers).forEach(removeLayer);
+    }, [config]);
+    const getSources = React__namespace.useCallback(() => {
+        if (!config)
+            return [];
+        const { sources } = config;
+        return Object.keys(sources);
+    }, [config]);
     React__namespace.useEffect(() => {
         if (isValidApiKey) {
             getLeafletLayer();
@@ -43509,10 +44051,120 @@ const useGetLeafletLayer = () => {
             });
         }
     }, [scene]);
+    React__namespace.useEffect(() => {
+        addStyle({
+            name: 'space-tile',
+            style: {
+                shaders: {
+                    defines: {
+                        TILE_SCALE: 0.0002445,
+                        'NORMALIZED_SHORT(x)': '(x * 32767.)',
+                    },
+                    blocks: {
+                        global: `
+              varying vec3 v_pos;
+              vec2 getTileCoords() {
+                return fract(v_pos.xy);
+              }
+            `,
+                        position: `
+              v_pos = modelPosition().xyz;
+            `,
+                    },
+                },
+            },
+        });
+        addStyle({
+            name: 'tools-aastep',
+            style: {
+                shaders: {
+                    extensions: 'OES_standard_derivatives',
+                    blocks: {
+                        global: `
+              float aastep(float threshold, float value) {
+                #ifdef TANGRAM_FRAGMENT_SHADER
+                  #ifdef TANGRAM_EXTENSION_OES_standard_derivatives
+                    float afwidth = length(vec2(dFdx(value), dFdy(value))) * 0.70710678118654757;
+                      return smoothstep(threshold-afwidth, threshold+afwidth, value);
+                  #else
+                    return step(threshold, value);
+                  #endif
+                #else
+                  return step(threshold, value);
+                #endif
+              }
+            `,
+                    },
+                },
+            },
+        });
+        addStyle({
+            name: 'pattern-diagonal-grid',
+            style: {
+                mix: ['space-tile', 'tools-aastep'],
+                shaders: {
+                    blocks: {
+                        global: `
+              float DiagonalGrid(float scale, float lineWidth) {
+                vec2 st = getTileCoords() * scale;
+
+                float d1 = mod(st.x + st.y, 1.0);
+                float line1 = aastep(lineWidth, d1) * aastep(1.0 - lineWidth, d1);
+
+                float d2 = mod(st.x - st.y, 1.0);
+                float line2 = aastep(lineWidth, d2) * aastep(1.0 - lineWidth, d2);
+
+                return max(line1, line2);
+              } 
+            `,
+                    },
+                },
+            },
+        });
+        addStyle({
+            name: 'diagonal-grid',
+            style: {
+                mix: 'pattern-diagonal-grid',
+                blend: 'screen',
+                base: 'polygons',
+                shaders: {
+                    blocks: {
+                        color: `
+              float grid = DiagonalGrid(12.0, 0.08);
+
+              color.a = grid;
+            `,
+                    },
+                },
+            },
+        });
+    }, [addStyle]);
+    React__namespace.useEffect(() => {
+        Object.values(exports.TangramSourceNames).forEach((name) => {
+            const url = sourceUrl[name];
+            addSource({
+                tile_size,
+                name,
+                url,
+                type: 'MVT',
+            });
+        });
+    }, [addSource]);
     return {
         layer,
         scene,
         config,
+        addSource,
+        getSource,
+        updateSource,
+        addLayer,
+        removeLayer,
+        addStyle,
+        getLayerVisibility,
+        toggleLayerVisibility,
+        getSources,
+        getLayers,
+        removeLayers,
     };
 };
 
@@ -43527,21 +44179,1223 @@ const LeafletLayer = () => {
     return null;
 };
 
-exports.API_METHODS = void 0;
-(function (API_METHODS) {
-    API_METHODS["GET"] = "GET";
-    API_METHODS["DELETE"] = "DELETE";
-    API_METHODS["PUT"] = "PUT";
-    API_METHODS["POST"] = "POST";
-})(exports.API_METHODS || (exports.API_METHODS = {}));
+const getBuiltupAreaLayers = (source) => {
+    const layers = [];
+    const data = {
+        source,
+        layer: '"MapAdminBuiltupArea"',
+    };
+    const layer = {
+        id: uuid(),
+        data,
+        draw: {
+            polygons: {
+                color: '#CFC8C8',
+            },
+        },
+    };
+    layers.push(layer);
+    return layers;
+};
 
-exports.PanelsNames = void 0;
-(function (PanelsNames) {
-    PanelsNames["TOP_RIGHT"] = "top-right";
-    PanelsNames["BOTTOM_RIGHT"] = "bottom-right";
-    PanelsNames["BOTTOM_LEFT"] = "bottom-left";
-    PanelsNames["TOP_LEFT"] = "top-left";
-})(exports.PanelsNames || (exports.PanelsNames = {}));
+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:
@@ -43608,7 +45462,35 @@ exports.LeafletLayer = LeafletLayer;
 exports.List = CustomList;
 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;
 //# sourceMappingURL=index.cjs.map