@mapcreator/sdk 0.0.7 → 0.0.9

package/dist/esm/renderAdornments.js

@@ -0,0 +1,129 @@
+import { useCustomAdornment } from '@/adornments/customAdornment';
+import { useConnectedLegend } from '@/adornments/connectedLegend';
+import { useManualLegend } from '@/adornments/manualLegend';
+import { useNorthArrow } from '@/adornments/northArrow';
+import { useWebControls } from '@/controls/webControls';
+import { useInsetMap } from '@/adornments/insetMap';
+import { useScalebar } from '@/adornments/scalebar';
+import { useHeading } from '@/adornments/heading';
+import { positionConfig } from '@/constants';
+const positions = [
+    'top_left',
+    'top_right',
+    'bottom_left',
+    'bottom_right',
+    'top_center',
+    'left_center',
+    'right_center',
+    'bottom_center',
+];
+const adornmentContainers = new Map();
+export function useRenderAdornments(jobObject, positionOffsets, map, initialPosition, vapiUrl, cdnUrl, accessToken) {
+    const { adornments = [] } = jobObject;
+    createContainers(map, positionOffsets);
+    adornments.forEach(adornment => {
+        if (adornment.type === 'custom') {
+            const customElement = useCustomAdornment(adornment);
+            addAdornment(customElement, adornment.position, adornment.stacking);
+        }
+        else if (adornment.type === 'scalebar') {
+            const scalebarElement = useScalebar(adornment, map);
+            addAdornment(scalebarElement, adornment.position, adornment.stacking);
+        }
+        else if (adornment.type === 'northArrow') {
+            const northArrowElement = useNorthArrow(adornment, map);
+            addAdornment(northArrowElement, adornment.position, adornment.stacking);
+        }
+        else if (adornment.type === 'webControls' && adornment.buttons) {
+            const webControlsElement = useWebControls(adornment, map, initialPosition);
+            addAdornment(webControlsElement, adornment.position, adornment.stacking);
+        }
+        else if (adornment.type === 'insetMap') {
+            const insetMapElement = useInsetMap(adornment, map, cdnUrl);
+            addAdornment(insetMapElement, adornment.position, adornment.stacking);
+        }
+        else if (adornment.type === 'heading') {
+            const headerElement = useHeading(adornment, vapiUrl, accessToken);
+            addAdornment(headerElement, adornment.position, adornment.stacking);
+        }
+        else if (adornment.type === 'manualLegend') {
+            const categoricalLegendElement = useManualLegend(adornment, vapiUrl, accessToken);
+            addAdornment(categoricalLegendElement, adornment.position, adornment.stacking);
+        }
+        else if (adornment.type === 'connectedLegend') {
+            const connectedLegendElement = useConnectedLegend(adornment, jobObject, map, vapiUrl, accessToken);
+            addAdornment(connectedLegendElement, adornment.position, adornment.stacking);
+        }
+    });
+    updateCollisionDetection(map);
+    map.on('moveend', () => updateCollisionDetection(map));
+}
+function createContainers(map, positionOffsets) {
+    const mapContainer = map.getContainer();
+    for (const position of positions) {
+        const container = document.createElement('div');
+        container.classList.add('adornment-container', `${position}`);
+        if (positionOffsets?.[position]) {
+            container.style.cssText = getContainerStyle(position, positionOffsets);
+        }
+        const horizontal = document.createElement('div');
+        const vertical = document.createElement('div');
+        container.classList.add('adornment-container', position);
+        horizontal.classList.add('inner');
+        vertical.classList.add('inner', 'vertical');
+        container.append(horizontal, vertical);
+        mapContainer.appendChild(container);
+        adornmentContainers.set(position, {
+            horizontal,
+            vertical,
+        });
+    }
+}
+function getContainerStyle(position, positionOffsets) {
+    const cfg = positionConfig[position];
+    const { x, y, unit } = positionOffsets[position];
+    let style = '';
+    const transforms = [];
+    if (cfg.x === 'center') {
+        transforms.push(`translateX(${x}${unit})`);
+    }
+    else {
+        style += `${cfg.x}: ${x}${unit};`;
+    }
+    if (cfg.y === 'center') {
+        transforms.push(`translateY(${y}${unit})`);
+    }
+    else if (position === 'bottom_right') {
+        style += `${cfg.y}: max(${y}${unit}, 25px);`;
+    }
+    else {
+        style += `${cfg.y}: ${y}${unit};`;
+    }
+    if (transforms.length) {
+        style += `transform: ${transforms.join(' ')};`;
+    }
+    return style;
+}
+function addAdornment(adornment, position, stacking) {
+    if (!stacking) {
+        stacking = ['left_center', 'right_center'].includes(position) ? 'vertical' : 'horizontal';
+    }
+    const container = adornmentContainers.get(position);
+    const dominantAxis = position === 'left_center' || position === 'right_center' ? 'vertical' : 'horizontal';
+    if (!container?.[dominantAxis].hasChildNodes()) {
+        stacking = dominantAxis;
+    }
+    const target = container?.[stacking];
+    target?.appendChild(adornment);
+}
+function updateCollisionDetection(map) {
+    const elements = Array.from(document.querySelectorAll('.adornment, .maplibregl-ctrl-attrib'));
+    const labelFreeAreas = [];
+    elements.forEach(el => {
+        const rect = el.getBoundingClientRect();
+        if (rect) {
+            labelFreeAreas.push([rect.x, rect.y, rect.x + rect.width, rect.y + rect.height]);
+        }
+    });
+    map.setLabelFreeAreas(labelFreeAreas);
+}

package/dist/esm/types/geometry.js

@@ -0,0 +1 @@
+export {};

package/dist/{types → esm/types}/index.d.ts

@@ -1,4 +1,4 @@
-import { JobObject, JobObjectDataBindings } from './jobObject';
+import type { JobObject, JobObjectDataBindings } from '@/types/jobObject';
 export type Svgs = Record<string, string>;
 export type ModelBindings = {
     dataBindings?: JobObjectDataBindings | undefined;

package/dist/esm/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/jobObject.js

@@ -0,0 +1 @@
+export {};

package/dist/{types → esm/types}/mapstyle.d.ts

@@ -1,5 +1,9 @@
-import { JobObjectModelType } from './jobObject';
-import { LayerSpecification } from '@mapcreator/maplibre-gl';
+/**
+ * These types are mostly copy-pasted from V5 and needs to stay in sync with it.
+ * TODO: consider extracting into a separate package
+ */
+import type { JobObjectModelType } from '@/types/jobObject';
+import type { LayerSpecification } from '@mapcreator/maplibre-gl';
 export type Anchor = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 export type Justify = 'left' | 'center' | 'right';
 export interface LabelStylePreset {

package/dist/esm/types/mapstyle.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/browser.js

@@ -0,0 +1,6 @@
+export function isMobile() {
+    return navigator.userAgent.toLowerCase().indexOf('mobile') >= 0;
+}
+export function isFirefox() {
+    return typeof window.InstallTrigger !== 'undefined';
+}

package/dist/{utils → esm/utils}/choropleth.d.ts

@@ -1,6 +1,6 @@
-import { ScaleLinear, ScaleOrdinal, ScaleQuantile, ScaleQuantize } from 'd3-scale';
-import { CategoricalGroup, JobObjectAreaGroup } from '../types/jobObject';
-import { ModelBindings } from '../types';
+import { type ScaleLinear, type ScaleOrdinal, type ScaleQuantile, type ScaleQuantize } from 'd3-scale';
+import type { CategoricalGroup, JobObjectAreaGroup } from '@/types/jobObject';
+import type { ModelBindings } from '@/types';
 export type ColorGenerator = ScaleLinear<string, string> | ScaleQuantile<string> | ScaleQuantize<string> | ScaleOrdinal<string, string>;
 export declare const legendTickCount = 4;
 export declare function getColorGenerator(group: JobObjectAreaGroup): ColorGenerator | undefined;

package/dist/esm/utils/choropleth.js

@@ -0,0 +1,110 @@
+import { interpolateHcl, piecewise, quantize } from 'd3-interpolate';
+import { extent, range } from 'd3-array';
+import { scaleLinear, scaleOrdinal, scaleQuantile, scaleQuantize, } from 'd3-scale';
+import { getBoundValues } from '@/utils/models';
+// constants/choropleth.ts
+const multiHue = [
+    ['#EDF8E9', '#BAE4B3', '#74C476', '#31A354', '#006D2C'],
+    ['#EFF3FF', '#BDD7E7', '#6BAED6', '#3182BD', '#08519C'],
+    ['#F0F9E8', '#BAE4BC', '#7BCCC4', '#43A2CA', '#0868AC'],
+    ['#EDF8FB', '#B3CDE3', '#8C96C6', '#8856A7', '#810F7C'],
+    ['#FEF0D9', '#FDCC8A', '#FC8D59', '#E34A33', '#B30000'],
+    ['#FEEBE2', '#FBB4B9', '#F768A1', '#C51B8A', '#7A0177'],
+    ['#D7191C', '#FDAE61', '#FFFFBF', '#ABDDA4', '#2B83BA'],
+    ['#7B3294', '#C2A5CF', '#F7F7F7', '#A6DBA0', '#008837'],
+];
+const singleHue = [
+// ['#F7F7F7', '#CCCCCC', '#969696', '#636363', '#252525'],
+// ['#EDF8E9', '#BAE4B3', '#74C476', '#31A354', '#006D2C'],
+// ['#FEEDDE', '#FDBE85', '#FD8D3C', '#E6550D', '#A63603'],
+// ['#FEE5D9', '#FCAE91', '#FB6A4A', '#DE2D26', '#A50F15'],
+// ['#EFF3FF', '#BDD7E7', '#6BAED6', '#3182BD', '#08519C'],
+// ['#F2F0F7', '#CBC9E2', '#9E9AC8', '#756BB1', '#54278F'],
+];
+// utils/import/pattern.ts
+const colourReArr = [
+    /transparent/,
+    /#[0-9a-fA-F]{3,4}/,
+    /#[0-9a-fA-F]{6}/,
+    /#[0-9a-fA-F]{8}/,
+    /rgba?\(\s*(?:(?:\d{1,3}%?|none)\s*,\s*){2}(?:\d{1,3}%?|none)(?:\s*,\s*(?:0|1|0?\.\d+|\d+%|none))?\s*\)/,
+    /rgba?\(\s*(?:\d{1,3}%?|none)\s+(?:\d{1,3}%?|none)\s+(?:\d{1,3}%?|none)(?:\s*\/\s*(?:0|1|0?\.\d+|\d+%|none))?\s*\)/,
+    /hsla?\(\s*(?:[+-]?\d*\.?\d+(?:deg|grad|rad|turn)?|none)\s*,\s*(?:\d{1,3}%|none)\s*,\s*(?:\d{1,3}%|none)(?:\s*,\s*(?:0|1|0?\.\d+|\d+%|none))?\s*\)/,
+    /hsla?\(\s*(?:[+-]?\d*\.?\d+(?:deg|grad|rad|turn)?|none)\s+(?:\d{1,3}%|none)\s+(?:\d{1,3}%|none)(?:\s*\/\s*(?:0|1|0?\.\d+|\d+%|none))?\s*\)/,
+    // /(?:oklab|oklch|lab|lch|hwb|color)\(\s*[^()]*\)/,
+];
+const colourReStr = colourReArr.map(re => re.toString().replace(/^\/|\/$/g, '')).join('|');
+const colourRe = new RegExp(`^\\s*(${colourReStr})\\s*$`);
+function linearDomain(values, colors) {
+    const [min, max] = extent(values);
+    const n = colors.length;
+    return range(n).map(i => min + (i * (max - min)) / (n - 1));
+}
+export const legendTickCount = 4;
+const colorMethods = {
+    linear: (values, colors) => scaleLinear(linearDomain(values, colors), colors)
+        .interpolate(interpolateHcl)
+        .nice(legendTickCount),
+    quantile: (values, colors) => scaleQuantile(values, colors),
+    quantize: (values, colors) => scaleQuantize(extent(values), colors).nice(),
+    categorical: (values, colors) => scaleOrdinal(values, colors),
+};
+export function getColorGenerator(group) {
+    if (group.choropleth) {
+        const values = getChoroplethValues(group);
+        const dataColumn = getColumnName(group.fillColor);
+        if (values && dataColumn) {
+            const { choropleth } = group;
+            const categoricalGroup = choropleth.categoricalColors[dataColumn];
+            const colors = choropleth.colorMode === 'categorical'
+                ? values.map(value => categoricalGroup.values[value])
+                : getColorSamples(choropleth.lowerColor, choropleth.upperColor, choropleth.colorMode !== 'linear' ? choropleth.colorCount : undefined);
+            return colorMethods[choropleth.colorMode](values, colors);
+        }
+    }
+}
+export function getChoroplethValues(group) {
+    if (group.choropleth) {
+        const dataColumn = group.fillColor?.match(/\$\{([^}]+)}/)?.[1];
+        if (dataColumn) {
+            const bindings = Object.values(group.models);
+            const values = getBoundValues(bindings, dataColumn);
+            if (!values.length ||
+                values.some(value => typeof value !== 'string' || !colourRe.test(value))) {
+                return group.choropleth.colorMode === 'categorical' ? Array.from(new Set(values)) : values;
+            }
+        }
+    }
+}
+export function getColorSamples(lowerColor, upperColor, colorCount) {
+    const stops = multiHue.find(r => r[0] === lowerColor && r[r.length - 1] === upperColor) ??
+        singleHue.find(r => r[0] === lowerColor && r[r.length - 1] === upperColor);
+    return stops
+        ? quantize(piecewise(interpolateHcl, stops), colorCount ?? stops.length)
+        : quantize(interpolateHcl(lowerColor, upperColor), colorCount ?? 2);
+}
+export function getColumnType(modelBindings, dataColumn) {
+    const values = dataColumn ? getBoundValues(modelBindings, dataColumn) : undefined;
+    return !values?.length
+        ? undefined
+        : values.every(value => typeof value === 'number')
+            ? 'number'
+            : values.every(value => typeof value === 'string' && colourRe.test(value))
+                ? 'color'
+                : 'string';
+}
+export function getColumnName(value) {
+    return value?.match(/\$\{([^}]+)}/)?.[1];
+}
+export function groupByColor(values) {
+    const result = Object.create(null);
+    for (const key in values) {
+        const value = values[key];
+        result[value] = value in result ? null : key;
+    }
+    return result;
+}
+export function isChoroplethColumn(modelBindings, dataColumn) {
+    const columnType = dataColumn ? getColumnType(modelBindings, dataColumn) : undefined;
+    return columnType !== undefined && columnType !== 'color';
+}

package/dist/esm/utils/fullscreen.js

@@ -0,0 +1,40 @@
+export function isFullscreenSupported() {
+    return Boolean(document.fullscreenEnabled ||
+        document.mozFullScreenEnabled ||
+        document.msFullscreenEnabled ||
+        document.webkitFullscreenEnabled);
+}
+export function isFullscreen(mapContainer) {
+    return (document.fullscreenElement === mapContainer ||
+        document.webkitFullscreenElement === mapContainer ||
+        document.mozFullScreenElement === mapContainer ||
+        document.msFullscreenElement === mapContainer);
+}
+export function enterFullscreen(mapContainer) {
+    if (mapContainer.requestFullscreen) {
+        mapContainer.requestFullscreen();
+    }
+    else if (mapContainer.mozRequestFullScreen) {
+        mapContainer.mozRequestFullScreen();
+    }
+    else if (mapContainer.msRequestFullscreen) {
+        mapContainer.msRequestFullscreen();
+    }
+    else if (mapContainer.webkitRequestFullscreen) {
+        mapContainer.webkitRequestFullscreen();
+    }
+}
+export function exitFullscreen() {
+    if (document.exitFullscreen) {
+        document.exitFullscreen();
+    }
+    else if (document.mozCancelFullScreen) {
+        document.mozCancelFullScreen();
+    }
+    else if (document.msExitFullscreen) {
+        document.msExitFullscreen();
+    }
+    else if (document.webkitCancelFullScreen) {
+        document.webkitCancelFullScreen();
+    }
+}

package/dist/{utils → esm/utils}/geolocation.d.ts

@@ -1,4 +1,4 @@
-import { Map } from '@mapcreator/maplibre-gl';
+import type { Map } from '@mapcreator/maplibre-gl';
 export declare const loadLocationDot: (map: Map) => void;
 export declare const initLayersAndSources: (map: Map) => void;
 export declare const addLocationDot: (map: any, lng: number, lat: number) => void;

package/dist/esm/utils/geolocation.js

@@ -0,0 +1,93 @@
+import locationDot from '@/images/location-dot.svg?raw';
+import { SvgCache } from '@/utils/svgHelpers';
+export const loadLocationDot = (map) => {
+    const pixelRatio = 2 * window.devicePixelRatio;
+    const svgCache = new SvgCache(map);
+    const imageKey = svgCache.getMapLibreImageKey(locationDot, pixelRatio);
+    map.setLayoutProperty('location-dot', 'icon-image', imageKey);
+};
+export const initLayersAndSources = (map) => {
+    if (!map.getSource('location-circle')) {
+        map.addSource('location-circle', {
+            type: 'geojson',
+            data: { type: 'FeatureCollection', features: [] },
+        });
+    }
+    if (!map.getSource('location-dot')) {
+        map.addSource('location-dot', {
+            type: 'geojson',
+            data: {
+                type: 'Feature',
+                geometry: { type: 'Point', coordinates: [] },
+                properties: {},
+            },
+        });
+    }
+    if (!map.getLayer('location-circle')) {
+        map.addLayer({
+            id: 'location-circle',
+            type: 'fill',
+            source: 'location-circle',
+            layout: {},
+            paint: {
+                'fill-color': '#349CF2',
+                'fill-opacity': 0.15,
+                'fill-outline-color': '#005196',
+            },
+        }, 'mc-before-names');
+    }
+    if (!map.getLayer('location-dot')) {
+        map.addLayer({
+            id: 'location-dot',
+            type: 'symbol',
+            source: 'location-dot',
+            layout: { 'icon-padding': 0 },
+            paint: { 'icon-opacity': 1 },
+            metadata: { 'mc-name': 'location dot', 'mc-skip-load': true },
+        }, 'mc-before-names');
+    }
+    loadLocationDot(map);
+};
+export const addLocationDot = (map, lng, lat) => {
+    const source = map.getSource('location-dot');
+    if (source) {
+        source.setData({
+            type: 'Feature',
+            geometry: { type: 'Point', coordinates: [lng, lat] },
+            properties: {},
+        });
+    }
+};
+export const createCircle = (lng, lat, meters) => {
+    const points = 64;
+    const km = meters / 1000;
+    const polygon = [];
+    const deltaX = km / (111.32 * Math.cos((lat * Math.PI) / 180));
+    const deltaY = km / 110.574;
+    for (let i = 0; i < points; i++) {
+        const angle = (i / points) * (2 * Math.PI);
+        const x = deltaX * Math.cos(angle);
+        const y = deltaY * Math.sin(angle);
+        polygon.push([lng + x, lat + y]);
+    }
+    polygon.push(polygon[0]);
+    return {
+        type: 'FeatureCollection',
+        features: [
+            {
+                type: 'Feature',
+                geometry: { type: 'Polygon', coordinates: [polygon] },
+            },
+        ],
+    };
+};
+export const showNotification = () => {
+    const mapContainer = document.querySelector('.map');
+    const notificationElem = document.createElement('div');
+    notificationElem.classList.add('location-notification');
+    notificationElem.textContent = 'Geolocation is not available';
+    mapContainer?.appendChild(notificationElem);
+    setTimeout(() => {
+        mapContainer?.removeChild(notificationElem);
+    }, 3000);
+};

package/dist/{utils → esm/utils}/graphhopper.d.ts

@@ -1,4 +1,4 @@
-import { LngLat } from '../types/geometry';
+import type { LngLat } from '@/types/geometry';
 export declare class GraphHopperGeocoderService {
     getLocationInBounds(location: string, center: LngLat, limit?: number): Promise<any>;
     _callGraphHopper(params: any): Promise<any>;

package/dist/esm/utils/graphhopper.js

@@ -0,0 +1,41 @@
+import { locale } from '@/i18n';
+export class GraphHopperGeocoderService {
+    async getLocationInBounds(location, center, limit = 10) {
+        try {
+            const results = await this._callGraphHopper({
+                limit,
+                q: location,
+                point: `${center.lat},${center.lng}`,
+            });
+            return this._mapResults(results.hits);
+        }
+        catch (e) {
+            console.warn('Geocoding failed: ', e);
+            return [];
+        }
+    }
+    async _callGraphHopper(params) {
+        const query = new URLSearchParams(params);
+        query.append('key', import.meta.env.VITE_GRAPHHOPPER_GEOCODING_CODE);
+        query.append('locale', locale.slice(0, 2));
+        const init = { headers: { Accept: 'application/json' } };
+        const url = `https://graphhopper.com/api/1/geocode?${query}`;
+        const response = await fetch(url, init);
+        const res = await response.json();
+        return res;
+    }
+    _mapResults(results) {
+        return results.map((r) => ({
+            id: r.osm_id.toString(),
+            labelTitle: r.name,
+            position: { lng: r.point.lng, lat: r.point.lat },
+            bbox: r.extent
+                ? [
+                    { lng: r.extent[0], lat: r.extent[1] },
+                    { lng: r.extent[2], lat: r.extent[3] },
+                ]
+                : null,
+            subtitle: [r.osm_value, r.city, r.state, r.country].filter(Boolean).join(', '),
+        }));
+    }
+}

package/dist/{utils → esm/utils}/helpers.d.ts

@@ -1,5 +1,5 @@
-import { JobObjectDataBindings, JobObjectStoredValue } from '../types/jobObject';
-import { LngLat } from '../types/geometry';
+import type { JobObjectDataBindings, JobObjectStoredValue } from '@/types/jobObject';
+import type { LngLat } from '@/types/geometry';
 export declare const numberRe: RegExp;
 export declare function degToRad(angle: number): number;
 export declare function radToDeg(angle: number): number;

package/dist/esm/utils/helpers.js

@@ -0,0 +1,116 @@
+export const numberRe = /^\s*[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?\s*$/;
+export function degToRad(angle) {
+    return (angle / 180) * Math.PI;
+}
+export function radToDeg(angle) {
+    return (angle * 180) / Math.PI;
+}
+export function calcDistance(lngLat1, lngLat2) {
+    const R = 6371000;
+    const rad = Math.PI / 180;
+    const lat1 = lngLat1.lat * rad;
+    const lat2 = lngLat2.lat * rad;
+    const a = Math.sin(lat1) * Math.sin(lat2) +
+        Math.cos(lat1) * Math.cos(lat2) * Math.cos((lngLat2.lng - lngLat1.lng) * rad);
+    return R * Math.acos(Math.min(a, 1));
+}
+export function stringToId(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash << 5) - hash + str.charCodeAt(i);
+        hash &= hash;
+    }
+    return Math.abs(hash);
+}
+/**
+ * Resolves a potential binding reference.
+ *
+ * 1. If the string starts with a $, it is considered a binding reference. The value of the binding
+ *    is then returned.
+ * 2. Otherwise, the string is returned as is.
+ */
+export function resolveBinding(str, bindings) {
+    return str.startsWith('$') ? bindingToString(bindings[str.slice(1)]) : str;
+}
+export function bindingToString(binding) {
+    return typeof binding === 'string'
+        ? binding
+        : typeof binding === 'number'
+            ? String(binding)
+            : typeof binding === 'boolean'
+                ? String(binding).toUpperCase()
+                : typeof binding === 'object' &&
+                    binding !== null &&
+                    (binding.t === 'n' || binding.t === 'd')
+                    ? (binding.w ?? '')
+                    : '';
+}
+export function bindingToPrimitive(binding) {
+    return typeof binding === 'string' && numberRe.test(binding)
+        ? Number(binding)
+        : typeof binding === 'string' || typeof binding === 'number' || typeof binding === 'boolean'
+            ? binding
+            : typeof binding === 'object' && binding !== null && binding.t === 'n'
+                ? binding.v
+                : null;
+}
+/* eslint-enable no-nested-ternary */
+export function getYoutubeVideoId(url) {
+    url = url.trim();
+    // Reference prefixed with a $ or video id
+    if (/^\$?[\w\-_]+$/.test(url)) {
+        return url;
+    }
+    const regex = /(?:https?:\/\/)?(?:www\.)?youtu\.?be(?:\.com)?\/?.*(?:watch|embed)?(?:.*v=|v\/|\/)([\w\-_]+)&?/;
+    return (regex.exec(url) || [])[1];
+}
+const baseDpi = 72;
+export function unitConvert(from, to, value) {
+    if (from === to) {
+        return value;
+    }
+    // Converters from MM to unit
+    const map = {
+        millimeter: 1,
+        centimeter: 0.1,
+        meter: 0.001,
+        kilometer: 0.000001,
+        foot: 0.00328084,
+        mile: 6.21371e-7,
+        nauticalMile: 5.39957e-7,
+        inch: 0.0393701,
+        pixel: 0.0393701 * baseDpi,
+        pica: 0.236222,
+    };
+    return (value / map[from]) * map[to];
+}
+export function lerp(value1, value2, ratio) {
+    return value1 + (value2 - value1) * ratio;
+}
+export function unlerp(min, max, value) {
+    return (value - min) / (max - min);
+}
+export function clamp(value, min, max) {
+    return Math.max(Math.min(value, max), min);
+}
+/**
+ * Fast hash function for non-cryptographic use
+ */
+export function fnv32b(str) {
+    const FNV1_32A_INIT = 0x811c9dc5;
+    let hash = str
+        .split('')
+        .map(x => x.charCodeAt(0))
+        .reduce((sum, val) => {
+        sum ^= val;
+        return sum + (sum << 1) + (sum << 4) + (sum << 7) + (sum << 8) + (sum << 24);
+    }, FNV1_32A_INIT);
+    // Avalanche
+    hash ^= hash << 3;
+    hash += hash >> 5;
+    hash ^= hash << 4;
+    hash += hash >> 17;
+    hash ^= hash << 25;
+    hash += hash >> 6;
+    return `0000000${(hash >>> 0).toString(16)}`.substr(-8);
+}

package/dist/{utils → esm/utils}/language.d.ts

@@ -1,4 +1,4 @@
-import { Map } from '@mapcreator/maplibre-gl';
+import type { Map } from '@mapcreator/maplibre-gl';
 export declare function setLanguage(language: string, map: Map): void;
 export declare const LanguageNotation: Readonly<{
     THREE: "ISO 639-2/B";