npm - becomap - Versions diffs - 1.6.0 → 1.6.2 - Mend

becomap 1.6.0 → 1.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/public/index.html ADDED Viewed

@@ -0,0 +1,500 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>Becomap UMD SDK</title>
+  <style>
+    body,
+    html {
+      margin: 0;
+      padding: 0;
+      height: 100%;
+    }
+    #mapContainer {
+      width: 100%;
+      height: 100%;
+    }
+  </style>
+</head>
+<body>
+  <div id="mapContainer"></div>
+  <!-- External libs -->
+  <script src="https://unpkg.com/maplibre-gl@4.4.1/dist/maplibre-gl.js"></script>
+  <script src="https://unpkg.com/@turf/turf@7.1.0/turf.min.js"></script>
+  <!-- Core Map SDK Integration -->
+  <script>
+    // ============================================================================
+    // GLOBAL VARIABLES
+    // ============================================================================
+    window._mapView = null;
+    window._site = null;
+    window._eventListeners = new Map();
+    // ============================================================================
+    // UTILITY FUNCTIONS
+    // ============================================================================
+    /**
+     * Sends messages to native platform (iOS/Android)
+     * @param {string} type - Message type
+     * @param {any} payload - Message payload
+     */
+    function notifyNative(type, payload = null) {
+      const message = JSON.stringify({ type, payload });
+      if (window.webkit?.messageHandlers?.jsHandler) {
+        // iOS
+        window.webkit.messageHandlers.jsHandler.postMessage(message);
+      } else if (window.jsHandler?.postMessage) {
+        // Android
+        window.jsHandler.postMessage(message);
+      } else {
+        console.log("Native handler not available:", message);
+      }
+    }
+    /**
+     * Safely converts objects to JSON with error handling
+     * @param {any} obj - Object to convert
+     * @returns {any} - JSON object or original object if conversion fails
+     */
+    function safeToJSON(obj) {
+      try {
+        return obj?.toJSON ? obj.toJSON() : obj;
+      } catch (error) {
+        console.warn('Error converting to JSON:', error);
+        return obj;
+      }
+    }
+    /**
+     * Executes function with error handling and native notification
+     * @param {Function} fn - Function to execute
+     * @param {string} errorType - Error type for native notification
+     * @param {any} fallbackValue - Fallback value if function fails
+     */
+    function executeWithErrorHandling(fn, errorType, fallbackValue = null) {
+      try {
+        const result = fn();
+        return result !== undefined ? result : fallbackValue;
+      } catch (error) {
+        console.error(`${errorType} error:`, error);
+        notifyNative(errorType, { message: error.message });
+        return fallbackValue;
+      }
+    }
+    // ============================================================================
+    // BCMapViewEvents CALLBACKS
+    // ============================================================================
+    /**
+     * Sets up event listeners for BCMapViewEvents
+     * @param {Object} mapView - The map view instance
+     */
+    function setupMapViewEventListeners(mapView) {
+      if (!mapView || !mapView.eventsHandler) {
+        console.warn('MapView does not support event listeners');
+        return;
+      }
+      // Clear existing listeners
+      clearMapViewEventListeners();
+      // Map load event
+      const loadListenerId = mapView.eventsHandler.on('load', () => {
+        notifyNative("mapLoad", { timestamp: Date.now() });
+      });
+      // View change event
+      const viewChangeListenerId = mapView.eventsHandler.on('viewChange', (args) => {
+        notifyNative("viewChange", {
+          viewOptions: safeToJSON(args.viewOptions),
+          timestamp: Date.now()
+        });
+      });
+      // Location selection event
+      const selectListenerId = mapView.eventsHandler.on('select', (args) => {
+        notifyNative("locationSelect", {
+          locations: args.locations?.map(loc => safeToJSON(loc)) || [],
+          timestamp: Date.now()
+        });
+      });
+      // Floor switch event
+      const switchToFloorListenerId = mapView.eventsHandler.on('switchToFloor', (args) => {
+        notifyNative("floorSwitch", {
+          floor: safeToJSON(args.floor),
+          timestamp: Date.now()
+        });
+      });
+      // Route step load event
+      const stepLoadListenerId = mapView.eventsHandler.on('stepLoad', (args) => {
+        notifyNative("stepLoad", {
+          step: safeToJSON(args.step),
+          timestamp: Date.now()
+        });
+      });
+      // Walkthrough end event
+      const walkthroughEndListenerId = mapView.eventsHandler.on('walkthroughEnd', () => {
+        notifyNative("walkthroughEnd", { timestamp: Date.now() });
+      });
+      // Store listener IDs for cleanup
+      window._eventListeners.set('load', loadListenerId);
+      window._eventListeners.set('viewChange', viewChangeListenerId);
+      window._eventListeners.set('select', selectListenerId);
+      window._eventListeners.set('switchToFloor', switchToFloorListenerId);
+      window._eventListeners.set('stepLoad', stepLoadListenerId);
+      window._eventListeners.set('walkthroughEnd', walkthroughEndListenerId);
+    }
+    /**
+     * Clears all map view event listeners
+     */
+    function clearMapViewEventListeners() {
+      if (!window._mapView || !window._mapView.eventsHandler) {
+        return;
+      }
+      window._eventListeners.forEach((listenerId, eventName) => {
+        try {
+          window._mapView.eventsHandler.off(eventName, listenerId);
+        } catch (error) {
+          console.warn(`Error removing ${eventName} listener:`, error);
+        }
+      });
+      window._eventListeners.clear();
+    }
+    // ============================================================================
+    // INITIALIZATION
+    // ============================================================================
+    /**
+     * Initializes the map with site options
+     * @param {Object} siteOptions - Site configuration options
+     */
+    async function init(siteOptions) {
+      try {
+        const container = document.getElementById('mapContainer');
+        if (!container) {
+          throw new Error('Map container not found');
+        }
+        if (!window.becomap?.getSite || !window.becomap?.getMapView) {
+          throw new Error('Becomap UMD not loaded');
+        }
+        const mapOptions = { zoom: 18.5 };
+        window._site = await window.becomap.getSite(siteOptions);
+        window._mapView = await window.becomap.getMapView(container, window._site, mapOptions);
+        // Setup event listeners
+        setupMapViewEventListeners(window._mapView);
+        notifyNative("onRenderComplete", {
+          site: safeToJSON(window._site),
+          timestamp: Date.now()
+        });
+      } catch (err) {
+        console.error('Init error:', err);
+        notifyNative("initError", {
+          message: err.message,
+          timestamp: Date.now()
+        });
+      }
+    }
+    // ============================================================================
+    // MAP VIEW METHODS
+    // ============================================================================
+    // Floor and Location Methods
+    globalThis.getCurrentFloor = () => {
+      const floor = executeWithErrorHandling(
+        () => window._mapView?.currentFloor,
+        "getCurrentFloorError"
+      );
+      notifyNative("getCurrentFloor", safeToJSON(floor));
+    };
+    globalThis.selectFloorWithId = (floor) => {
+      executeWithErrorHandling(
+        () => window._mapView?.selectFloorWithId(floor),
+        "selectFloorError"
+      );
+    };
+    globalThis.selectLocationWithId = (location) => {
+      executeWithErrorHandling(
+        () => window._mapView?.selectLocationWithId(location),
+        "selectLocationError"
+      );
+    };
+    // Data Retrieval Methods
+    globalThis.getCategories = () => {
+      const categories = executeWithErrorHandling(
+        () => window._mapView?.getCategories(),
+        "getCategoriesError",
+        []
+      );
+      notifyNative("getCategories", categories?.map(cat => safeToJSON(cat)) || []);
+    };
+    globalThis.getLocations = () => {
+      const locations = executeWithErrorHandling(
+        () => window._mapView?.getLocations(),
+        "getLocationsError",
+        []
+      );
+      notifyNative("getLocations", locations?.map(loc => safeToJSON(loc)) || []);
+    };
+    globalThis.getAllAmenities = () => {
+      const amenities = executeWithErrorHandling(
+        () => window._mapView?.getAllAminityLocations(),
+        "getAllAmenitiesError",
+        []
+      );
+      notifyNative("getAllAmenities", amenities?.map(amenity => safeToJSON(amenity)) || []);
+    };
+    globalThis.getAmenities = () => {
+      const amenities = executeWithErrorHandling(
+        () => window._mapView?.getAmenities(),
+        "getAmenitiesError",
+        []
+      );
+      notifyNative("getAmenities", amenities?.map(amenity => safeToJSON(amenity)) || []);
+    };
+    globalThis.selectAmenities = (type) => {
+      executeWithErrorHandling(
+        () => window._mapView?.selectAmenities(type),
+        "selectAmenitiesError"
+      );
+    };
+    // Session and Event Methods
+    globalThis.getSessionId = async () => {
+      try {
+        const sessionId = await window._mapView?.getSessionId();
+        notifyNative("getSessionId", sessionId);
+      } catch (err) {
+        notifyNative("getSessionIdError", {
+          message: err.message,
+          timestamp: Date.now()
+        });
+      }
+    };
+    globalThis.getQuestions = () => {
+      const questions = executeWithErrorHandling(
+        () => window._mapView?.getQuestions(),
+        "getQuestionsError",
+        []
+      );
+      notifyNative("getQuestions", questions?.map(q => safeToJSON(q)) || []);
+    };
+    globalThis.getHappenings = (type) => {
+      const happenings = executeWithErrorHandling(
+        () => window._mapView?.getHappenings(type),
+        "getHappeningsError",
+        []
+      );
+      notifyNative("getHappenings", happenings?.map(h => safeToJSON(h)) || []);
+    };
+    globalThis.getEventSuggestions = async (sessionId, answers) => {
+      try {
+        const suggestions = await window._mapView?.getEventSuggestions(sessionId, answers);
+        notifyNative("getEventSuggestions", suggestions?.map(s => safeToJSON(s)) || []);
+      } catch (err) {
+        notifyNative("getEventSuggestionsError", {
+          message: err.message,
+          timestamp: Date.now()
+        });
+      }
+    };
+    // Viewport and Camera Methods
+    globalThis.focusTo = (location, zoom, bearing, pitch) => {
+      executeWithErrorHandling(
+        () => window._mapView?.focusTo(location, zoom, bearing, pitch),
+        "focusToError"
+      );
+    };
+    globalThis.clearSelection = () => {
+      executeWithErrorHandling(
+        () => window._mapView?.clearSelection(),
+        "clearSelectionError"
+      );
+    };
+    globalThis.updateZoom = (zoom) => {
+      executeWithErrorHandling(
+        () => window._mapView?.updateZoom(zoom),
+        "updateZoomError"
+      );
+    };
+    globalThis.updatePitch = (pitch) => {
+      executeWithErrorHandling(
+        () => window._mapView?.updatePitch(pitch),
+        "updatePitchError"
+      );
+    };
+    globalThis.updateBearing = (bearing) => {
+      executeWithErrorHandling(
+        () => window._mapView?.updateBearing(bearing),
+        "updateBearingError"
+      );
+    };
+    globalThis.enableMultiSelection = (val) => {
+      executeWithErrorHandling(
+        () => window._mapView?.enableMultiSelection(val),
+        "enableMultiSelectionError"
+      );
+    };
+    globalThis.setBounds = (sw, ne) => {
+      executeWithErrorHandling(
+        () => window._mapView?.setBounds(sw, ne),
+        "setBoundsError"
+      );
+    };
+    globalThis.setViewport = (options) => {
+      executeWithErrorHandling(
+        () => window._mapView?.setViewport(options),
+        "setViewportError"
+      );
+    };
+    globalThis.resetDefaultViewport = (options) => {
+      executeWithErrorHandling(
+        () => window._mapView?.resetDefaultViewport(options),
+        "resetDefaultViewportError"
+      );
+    };
+    // Search Methods
+    globalThis.searchForLocations = (q, callbackId) => {
+      if (!window._mapView?.searchForLocations) {
+        notifyNative("searchForLocations", {
+          callbackId,
+          results: [],
+          error: "Search method not available"
+        });
+        return;
+      }
+      window._mapView.searchForLocations(q, (matches) => {
+        notifyNative("searchForLocations", {
+          callbackId,
+          results: matches?.map(m => safeToJSON(m)) || []
+        });
+      });
+    };
+    globalThis.searchForCategories = (q, callbackId) => {
+      if (!window._mapView?.searchForCategories) {
+        notifyNative("searchForCategories", {
+          callbackId,
+          results: [],
+          error: "Search method not available"
+        });
+        return;
+      }
+      window._mapView.searchForCategories(q, (matches) => {
+        notifyNative("searchForCategories", {
+          callbackId,
+          results: matches?.map(m => safeToJSON(m)) || []
+        });
+      });
+    };
+    // ============================================================================
+    // ROUTE CONTROLLER METHODS
+    // ============================================================================
+    globalThis.getRoute = (startID, goalID, waypoints = [], routeOptions) => {
+      try {
+        const routes = window.becomap.getRouteById(startID, goalID, waypoints, routeOptions);
+        notifyNative("getRoute", routes?.map(route => safeToJSON(route)) || []);
+      } catch (error) {
+        notifyNative("getRouteError", {
+          message: error.message,
+          timestamp: Date.now()
+        });
+      }
+    };
+    globalThis.showRoute = () => {
+      executeWithErrorHandling(
+        () => window._mapView?.routeController?.showSavedRoute(),
+        "showRouteError"
+      );
+    };
+    globalThis.showStep = (step) => {
+      executeWithErrorHandling(
+        () => window._mapView?.routeController?.showStepByOrderIndex(step),
+        "showStepError"
+      );
+    };
+    globalThis.clearAllRoutes = () => {
+      executeWithErrorHandling(
+        () => window._mapView?.routeController?.clearAllRoutes(),
+        "clearAllRoutesError"
+      );
+    };
+    // ============================================================================
+    // CLEANUP AND EXPORTS
+    // ============================================================================
+    /**
+     * Cleanup function to be called when the webview is destroyed
+     */
+    globalThis.cleanup = () => {
+      clearMapViewEventListeners();
+      window._mapView = null;
+      window._site = null;
+    };
+    // Export init function
+    globalThis.init = init;
+  </script>
+  <!-- <script>
+    const siteOptions = {
+      clientId: "c079dfa3a77dad13351cfacd95841c2c2780fe08",
+      clientSecret: "f62a59675b2a47ddb75f1f994d88e653",
+      siteIdentifier: "67dcf5dd2f21c64e3225254f"
+    };
+    window.addEventListener("DOMContentLoaded", () => {
+      init(siteOptions);
+    });
+  </script> -->
+</body>
+</html>

package/webpack.umd.config.js ADDED Viewed

@@ -0,0 +1,91 @@
+const path = require('path');
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+const WebpackObfuscator = require('webpack-obfuscator');
+const TerserPlugin = require('terser-webpack-plugin');
+const Dotenv = require('dotenv-webpack');
+const envFile = `.env`;
+module.exports = {
+  mode: 'production',
+  entry: './src/index.ts',
+  output: {
+    filename: 'becomap.[contenthash].js',
+    chunkFilename: 'becomap.[name].[contenthash].js',
+    path: path.resolve(__dirname, 'esm-build'),
+    library: 'becomap',
+    libraryTarget: 'umd',
+    umdNamedDefine: true,
+    globalObject: 'this',
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+      {
+        test: /\.css$/,
+        use: ['style-loader', 'css-loader'],
+      },
+      {
+        test: /\.(eot|svg|ttf|woff|woff2|png|jpg|gif)$/i,
+        type: 'asset',
+      },
+    ],
+  },
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new TerserPlugin({
+        terserOptions: {
+          compress: {
+            drop_console: false,
+          },
+        },
+      }),
+    ],
+    splitChunks : {
+        chunks: 'all',
+        minSize: 30000,
+        maxSize: 204800,
+        cacheGroups: {
+            vendors: {
+                test: /[\\/]node_modules[\\/]/,
+                name: 'vendors',
+                enforce: true,
+                priority: -10,
+              },
+              default: {
+                minChunks: 2,
+                priority: -20,
+                reuseExistingChunk: true,
+              },
+        }
+    },
+    runtimeChunk: 'single'
+  },
+  externalsType: 'window',
+  externals: {
+    'maplibre-gl': 'maplibregl',
+    '@turf/turf':  'turf'
+  },
+  plugins: [
+    new Dotenv({
+      path: envFile,
+    }),
+    new HtmlWebpackPlugin({
+      template: './public/index.html',
+      filename: 'index.html',
+      inject: 'body',
+    }),
+    new WebpackObfuscator(
+      { stringArray: false },
+      ['node_modules/**/*']
+    ),
+  ],
+};