@mappedin/react-native-sdk 3.4.4 → 4.0.4-alpha.8

package/dist/get-venue/src/utils.js

@@ -1,188 +0,0 @@
-import { LatLonSpherical } from 'geodesy';
-import { MappedinLocation } from './MappedinLocation';
-import { MappedinPolygon } from './MappedinPolygon';
-export function isGatewayKey(key) {
-    // If the key is a hexidecimal value, it is used for api-gateway
-    const re = /^[\da-f]{24}$/i;
-    return re.test(key);
-}
-export function stringifyQuery(query, gateway = false) {
-    let queryString = '';
-    if (query != null) {
-        let delim = '?';
-        const keys = gateway
-            ? Object.keys(query).filter((key) => !['slug', 'venue'].includes(key))
-            : Object.keys(query);
-        for (let i = 0, iLen = keys.length; i < iLen; ++i) {
-            const name = keys[i];
-            const value = query[name];
-            if (value != null) {
-                queryString += `${delim + encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-                delim = '&';
-            }
-        }
-    }
-    return queryString;
-}
-export function buildUrl(options, pathname, query, supplementary = false) {
-    if (supplementary) {
-        return `${options.supplementaryUrl}${pathname}?venue=${query.venue || query.slug}`;
-    }
-    if (!options.baseUrl?.includes('gateway')) {
-        return options.baseUrl + pathname + stringifyQuery(query);
-    }
-    return `${options.baseUrl}${pathname}/${query.venue || query.slug}${stringifyQuery(query, options.baseUrl?.includes('gateway'))}`;
-}
-export async function getArray(options, pathname, query, supplementary = false) {
-    return getObject(options, pathname, query, supplementary, true);
-}
-export async function getObject(options, pathname, query, supplementary = false, isExpectingArray = false) {
-    const url = buildUrl(options, pathname, query, supplementary);
-    const res = await generateAPIRequest(options, url, supplementary);
-    if (!isExpectingArray && Array.isArray(res)) {
-        if (res.length === 1) {
-            return res[0];
-        }
-        throw new Error('Invalid response object');
-    }
-    else {
-        return res;
-    }
-}
-export async function generateAPIRequest(options, url, supplementary = false) {
-    /*
-    If not supplementary: fail on a non-OK response
-    If supplementary: always succeed
-    */
-    const requestOptions = {
-        language: options.language,
-        clientId: options.clientId,
-        clientSecret: options.clientSecret,
-    };
-    if (supplementary) {
-        delete requestOptions.language;
-    }
-    if (requestOptions.language) {
-        url += `&lang=${encodeURIComponent(requestOptions.language)}`;
-    }
-    const { headers } = options;
-    headers['Content-Type'] = 'text/json';
-    if (options.authorization) {
-        headers.Authorization = options.authorization;
-    }
-    if (requestOptions.language) {
-        headers['Accept-Language'] = requestOptions.language;
-    }
-    const req = {
-        method: 'GET',
-        headers,
-    };
-    const response = await fetch(url, req);
-    if (!response.ok) {
-        throw new Error(`${response.status} ${response.statusText}`);
-    }
-    return response.json();
-}
-export function addToSet(array, value) {
-    if (array.indexOf(value) < 0) {
-        array.push(value);
-    }
-}
-export function getDistanceBetweenLatLon([lat1, lon1], [lat2, lon2]) {
-    const ll1 = new LatLonSpherical(lat1, lon1);
-    const ll2 = new LatLonSpherical(lat2, lon2);
-    return ll1.distanceTo(ll2);
-}
-export function getMapScale(map) {
-    // Current field is x_scale but might move in the future
-    if (map.scale || map.x_scale) {
-        return 1 / (map.scale || map.x_scale);
-    }
-    let mapScale;
-    try {
-        const anchor1 = map.georeference[0];
-        const anchor2 = map.georeference[2];
-        // create two points, based on top-left, and bottom-right of the map in lat lon
-        const ll1 = new LatLonSpherical(anchor1.target.x, anchor1.target.y);
-        const ll2 = new LatLonSpherical(anchor2.target.x, anchor2.target.y);
-        // get real world distance between these points
-        const worldDistance = ll1.distanceTo(ll2);
-        const xDiff = anchor1.control.x - anchor2.control.x;
-        const yDiff = anchor1.control.y - anchor2.control.y;
-        // c = √(a² + b²) get distance in mappedin units
-        const mapDistance = Math.sqrt(xDiff * xDiff + yDiff * yDiff);
-        // scale === mappedin distance/ world distance
-        mapScale = mapDistance / worldDistance;
-    }
-    catch (e) {
-        mapScale = 1;
-        console.warn(e);
-        console.warn(`Couldn't georeference ${map.name || map.shortName || map.id}. Probably not enough geocoordinates.`);
-    }
-    return mapScale;
-}
-export function getNodesForNavigatable(obj) {
-    if (obj instanceof MappedinPolygon) {
-        return obj.entrances.map((node) => node.id);
-    }
-    else if (obj instanceof MappedinLocation) {
-        return obj.nodes?.map((node) => node.id) || [];
-    }
-    else {
-        return [obj.id];
-    }
-}
-export async function preloadImagesFromBundle(data) {
-    const imageBlobMap = {};
-    const { maps, images, scenes, polygons } = data;
-    if (images != null) {
-        try {
-            const promises = Object.keys(images).map((filename) => {
-                return fetch(`data:image/png;base64,${images[filename]}`)
-                    .then((res) => {
-                    return res.blob();
-                })
-                    .then((blob) => {
-                    imageBlobMap[filename] = blob;
-                })
-                    .catch((e) => {
-                    console.error(e);
-                });
-            });
-            await Promise.all(promises);
-        }
-        catch (e) {
-            console.error(e);
-        }
-    }
-    maps.forEach((m) => {
-        if (scenes != null) {
-            m.scene.polygons = scenes[m.id];
-        }
-        if (images != null) {
-            m.scene.images = m.scene.images.map(({ filename }) => ({
-                filename,
-                url: imageBlobMap[filename],
-            }));
-            m.scene.polygons.forEach((p) => {
-                if (p?.image?.url) {
-                    p.image.url = imageBlobMap[p.image.url.split('uploads/')[1]];
-                }
-            });
-        }
-    });
-    if (images != null) {
-        polygons.forEach((p) => {
-            if (p?.image?.url) {
-                p.image.url = imageBlobMap[p.image.url.split('uploads/')[1]];
-            }
-        });
-    }
-    if (data.images != null) {
-        delete data.images;
-    }
-    if (data.scenes != null) {
-        delete data.scenes;
-    }
-    return data;
-}

package/dist/get-venue/tsconfig.docs.json

@@ -1,7 +0,0 @@
-{
-    "extends": "./tsconfig.isomorphic.json",
-    "compilerOptions": {
-        "noEmit": true,
-        "emitDeclarationOnly": false
-    }
-}

package/dist/get-venue/tsconfig.isomorphic.json

@@ -1,20 +0,0 @@
-{
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "jsx": "react-native",
-        "outDir": "dist",
-        "isolatedModules": true,
-        "declaration": true,
-        "sourceMap": false,
-        "resolveJsonModule": true,
-        "declarationMap": true,
-        "emitDeclarationOnly": true,
-        "composite": true,
-        "allowJs": true,
-        "lib": ["ES2019"],
-        "module": "commonjs",
-        "target": "ES2019"
-    },
-    "include": ["**/*.ts", "**/*.tsx", "**/*.json"],
-    "exclude": ["node_modules", "src/**/*.test.ts", "src/fixtures/**"]
-}