@mapcreator/sdk 0.0.9 → 0.0.11

package/dist/esm/utils/models.js

@@ -1,103 +0,0 @@
-import { degToRad, radToDeg, calcDistance, numberRe, fnv32b } from '@/utils/helpers';
-import { lineString, polygon as makePolygon } from '@turf/helpers';
-import { polygonSmooth } from '@turf/polygon-smooth';
-import bboxClip from '@turf/bbox-clip';
-export function calculateCircle(center, radius) {
-    const circle = [];
-    const steps = 100;
-    const interval = (Math.PI * 2) / steps;
-    for (let i = 0; i < steps; i++) {
-        circle.push(calculateCirclePoint(center, radius, i * interval));
-    }
-    if (containsNorthPole(center, radius)) {
-        const first = circle[0];
-        const last = circle[circle.length - 1];
-        const lng = (last[0] + first[0] - 360) / 2;
-        const lat = (first[1] + last[1]) / 2;
-        circle.push([lng, lat]);
-        circle.push([lng, 90]);
-        circle.push([lng + 360, 90]);
-        circle.push([lng + 360, lat]);
-    }
-    if (containsSouthPole(center, radius)) {
-        const first = circle[49];
-        const last = circle[50];
-        const lng = (last[0] + first[0] - 360) / 2;
-        const lat = (first[1] + last[1]) / 2;
-        circle.splice(50, 0, [lng + 360, lat], [lng + 360, -90], [lng, -90], [lng, lat]);
-    }
-    circle.push(circle[0]);
-    return circle;
-}
-export function calculateRadiusLine(center, radius, bearing) {
-    const points = [];
-    const steps = 100;
-    const interval = radius / steps;
-    for (let i = 0; i <= steps; i++) {
-        points.push(calculateCirclePoint(center, i * interval, degToRad(bearing)));
-    }
-    const bbox = [-Infinity, -85.051129, Infinity, 85.051129];
-    return bboxClip(lineString(points), bbox).geometry.coordinates;
-}
-function calculateCirclePoint(center, radius, bearing) {
-    const earthRadius = 6378.1;
-    const radiusRatio = radius / earthRadius;
-    const lngCenter = degToRad(center.lng);
-    const latCenter = degToRad(center.lat);
-    const lat = Math.asin(Math.sin(latCenter) * Math.cos(radiusRatio) +
-        Math.cos(latCenter) * Math.sin(radiusRatio) * Math.cos(bearing));
-    const lng = lngCenter +
-        Math.atan2(Math.sin(bearing) * Math.sin(radiusRatio) * Math.cos(latCenter), Math.cos(radiusRatio) - Math.sin(latCenter) * Math.sin(lat));
-    return [radToDeg(lng), radToDeg(lat)];
-}
-function containsNorthPole(center, radius) {
-    return calcDistance(center, { lng: 0, lat: 90 }) / 1000 < radius;
-}
-function containsSouthPole(center, radius) {
-    return calcDistance(center, { lng: 0, lat: -90 }) / 1000 < radius;
-}
-export function calculatePolygonGeometry(polygon) {
-    const { polygonType } = polygon;
-    const anchorPoints = typeof polygon.anchorPoints?.[0]?.[0] === 'number'
-        ? [polygon.anchorPoints]
-        : polygon.anchorPoints;
-    if (polygonType === 'smooth') {
-        return (polygonSmooth(makePolygon(anchorPoints), { iterations: 4 }).features?.[0]?.geometry
-            ?.coordinates ?? anchorPoints.slice());
-    }
-    return anchorPoints.slice();
-}
-export function getAreaLayerId(groupId, area) {
-    const key = fnv32b(`${area.vectorUrl}/${area.sourceLayerId}`);
-    return `${groupId}-${key}`;
-}
-export function getAreaSourceId(area) {
-    return `custom-area-${fnv32b(area.vectorUrl)}`;
-}
-export function getBoundValues(modelBindings, dataColumn) {
-    return modelBindings.reduce((result, bindings) => {
-        const value = bindings.dataBindings?.[dataColumn];
-        if (typeof value === 'object' && value !== null && value.t === 'n') {
-            result.push(value.v);
-        }
-        else if (typeof value === 'number') {
-            result.push(value);
-        }
-        else if (typeof value === 'string' && value) {
-            result.push(numberRe.test(value) ? Number(value) : value);
-        }
-        return result;
-    }, []);
-}
-export function getLineAngle(line, map) {
-    const n = line.length;
-    if (n < 2) {
-        return 0;
-    }
-    const endPoint = map.projectWithScaleCorrection(line[n - 1]);
-    const penultimatePoint = map.projectWithScaleCorrection(line[n - 2]);
-    const dx = endPoint.x - penultimatePoint.x;
-    const dy = penultimatePoint.y - endPoint.y;
-    const thetaDeg = Math.atan2(dy, dx) * (180 / Math.PI);
-    return (90 - thetaDeg + 360) % 360;
-}

package/dist/esm/utils/overlays.js

@@ -1,87 +0,0 @@
-export async function loadOverlays(overlays, map, vapiUrl, accessToken, styleOverrides) {
-    const urls = overlays.map(overlay => `${vapiUrl}/styles/${overlay}.json?access_token=${accessToken}`);
-    const promises = urls.map(url => fetch(url).then(result => result.json()));
-    const data = await Promise.all(promises);
-    await Promise.all(data.map(item => addOverlay(item, map, accessToken, styleOverrides)));
-}
-async function addOverlay(data, map, accessToken, styleOverrides) {
-    for (const sourceId in data.sources) {
-        if (map.getSource(sourceId) === undefined) {
-            map.addSource(sourceId, data.sources[sourceId]);
-        }
-    }
-    if (data.sprite !== undefined) {
-        await loadSprite(map, data.sprite, accessToken);
-    }
-    for (const layer of data.layers) {
-        if (map.getLayer(layer.id) !== undefined) {
-            map.removeLayer(layer.id);
-        }
-        const addBefore = layer.metadata?.['mc-add-before'] ?? 'mc-before-none';
-        map.addLayer(applyOverrides(layer, styleOverrides), addBefore);
-    }
-}
-function applyOverrides(layer, styleOverrides) {
-    const overrides = styleOverrides ?? {};
-    const override = overrides[layer.id] ?? {};
-    const result = {
-        ...layer,
-        layout: { ...layer.layout, ...override.layout },
-        paint: { ...layer.paint, ...override.paint },
-        metadata: {
-            ...layer.metadata,
-            ...override.metadata,
-        },
-    };
-    if (override.minzoom !== undefined) {
-        result.minzoom = override.minzoom;
-    }
-    if (override.maxzoom !== undefined) {
-        result.maxzoom = override.maxzoom;
-    }
-    if ('filter' in override && result.type !== 'background') {
-        result.filter = override.filter;
-    }
-    return result;
-}
-async function loadSprite(map, spriteUrl, accessToken) {
-    try {
-        const spriteJsonUrl = `${spriteUrl}.json?access_token=${accessToken}`;
-        const spriteImageUrl = `${spriteUrl}.png?access_token=${accessToken}`;
-        const [spriteJsonResponse, spriteImageResponse] = await Promise.all([
-            fetch(spriteJsonUrl),
-            fetch(spriteImageUrl),
-        ]);
-        if (!spriteJsonResponse.ok || !spriteImageResponse.ok) {
-            throw new Error(`Failed to load sprite from ${spriteUrl}`);
-        }
-        const spriteJson = await spriteJsonResponse.json();
-        const spriteImageBlob = await spriteImageResponse.blob();
-        const spriteImage = await new Promise((resolve, reject) => {
-            const img = new Image();
-            img.onload = () => resolve(img);
-            img.onerror = err => reject(err);
-            img.src = URL.createObjectURL(spriteImageBlob);
-        });
-        const canvas = document.createElement('canvas');
-        const context = canvas.getContext('2d', { willReadFrequently: true });
-        if (!context) {
-            throw new Error('Failed to get canvas context');
-        }
-        for (const [name, sprite] of Object.entries(spriteJson)) {
-            if (map.hasImage(name)) {
-                continue;
-            }
-            const { x, y, width, height, pixelRatio } = sprite;
-            canvas.width = width * pixelRatio;
-            canvas.height = height * pixelRatio;
-            context.clearRect(0, 0, canvas.width, canvas.height);
-            context.drawImage(spriteImage, x, y, width, height, 0, 0, canvas.width, canvas.height);
-            const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
-            map.addImage(name, imageData, { pixelRatio });
-        }
-    }
-    catch (error) {
-        console.error(error);
-    }
-}

package/dist/esm/utils/scalebar.js

@@ -1,52 +0,0 @@
-const significantNumbers = [10, 5, 3, 2, 1];
-export function floatToFraction(x, error = 0.000001) {
-    const n = Math.floor(x);
-    x -= n;
-    if (x < error) {
-        return [n, 1];
-    }
-    else if (1 - error < x) {
-        return [n + 1, 1];
-    }
-    // The lower fraction is 0/1
-    let lowerN = 0;
-    let lowerD = 1;
-    // The upper fraction is 1/1
-    let upperN = 1;
-    let upperD = 1;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        // The middle fraction is (lowerN upperN) / (lower_d + upperD)
-        const middleN = lowerN + upperN;
-        const middleD = lowerD + upperD;
-        // If x + error < middle
-        if (middleD * (x + error) < middleN) {
-            // Middle is the new upper
-            upperN = middleN;
-            upperD = middleD;
-        }
-        else if (middleN < (x - error) * middleD) {
-            // Middle is the new lower
-            lowerN = middleN;
-            lowerD = middleD;
-        }
-        else {
-            // Middle is best fraction
-            return [n * middleD + middleN, middleD];
-        }
-    }
-}
-export function getRoundNum(num) {
-    const pow10 = 10 ** Math.floor(Math.log10(num));
-    const d = num / pow10;
-    for (const n of significantNumbers) {
-        if (d >= n) {
-            return n * pow10;
-        }
-    }
-    return getDecimalRoundNum(d) * pow10;
-}
-function getDecimalRoundNum(d) {
-    const multiplier = 10 ** Math.ceil(-Math.log(d) / Math.LN10);
-    return Math.round(d * multiplier) / multiplier;
-}