@kiva/kv-components 3.37.0 → 3.38.1

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.38.1](https://github.com/kiva/kv-ui-elements/compare/@kiva/kv-components@3.38.0...@kiva/kv-components@3.38.1) (2023-08-30)
+
+
+### Bug Fixes
+
+* kvmap component refactor to avoid using vue meta package ([#287](https://github.com/kiva/kv-ui-elements/issues/287)) ([72f5240](https://github.com/kiva/kv-ui-elements/commit/72f524037358f039032ebd1c8d1f4e106ab6ff10))
+
+
+
+
+
+# [3.38.0](https://github.com/kiva/kv-ui-elements/compare/@kiva/kv-components@3.37.0...@kiva/kv-components@3.38.0) (2023-08-29)
+
+
+### Features
+
+* kvmap ported to kv components library ([#286](https://github.com/kiva/kv-ui-elements/issues/286)) ([373e53f](https://github.com/kiva/kv-ui-elements/commit/373e53fd407d161e79033826a6063fbd5ca5b2ce))
+
+
+
+
+
 # [3.37.0](https://github.com/kiva/kv-ui-elements/compare/@kiva/kv-components@3.36.0...@kiva/kv-components@3.37.0) (2023-08-18)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kiva/kv-components",
-  "version": "3.37.0",
+  "version": "3.38.1",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -75,5 +75,5 @@
       "optional": true
     }
   },
-  "gitHead": "a617796f8021d568415c8d07b9a9f97e9c33595e"
+  "gitHead": "75d76cdba8cf94ff0ae555f9933fcbd038df8404"
 }

package/vue/KvMap.vue

@@ -0,0 +1,350 @@
+<template>
+	<div
+		class="tw-relative tw-block tw-w-full"
+		:style="mapDimensions"
+	>
+		<div
+			:id="`kv-map-holder-${mapId}`"
+			:ref="refString"
+			class="tw-w-full tw-h-full tw-bg-black"
+			:style="{ position: 'absolute' }"
+		></div>
+	</div>
+</template>
+
+<script>
+export default {
+	name: 'KvMap',
+	props: {
+		/**
+		 * Aspect Ration for computed map dimensions
+		 * We'll divide the container width by this to determine the height
+		 */
+		aspectRatio: {
+			type: Number,
+			default: 1,
+		},
+		/**
+		 * Control how quickly the autoZoom occurs
+		 */
+		autoZoomDelay: {
+			type: Number,
+			default: 1500,
+		},
+		/**
+		 * Set the height to override aspect ratio driven and/or default dimensions
+		 */
+		height: {
+			type: Number,
+			default: null,
+		},
+		/**
+		 * Setting this initialZoom will zoom the map from initialZoom to zoom when the map enters the viewport
+		 */
+		initialZoom: {
+			type: Number,
+			default: null,
+		},
+		/**
+		 * Set the center point latitude
+		 */
+		lat: {
+			type: Number,
+			default: null,
+		},
+		/**
+		 * Set the center point longitude
+		 */
+		long: {
+			type: Number,
+			default: null,
+		},
+		/**
+		 * Set this if there are more than one map on the page
+		 */
+		mapId: {
+			type: Number,
+			default: 0,
+		},
+		/**
+		 * Force use of Leaflet
+		 */
+		useLeaflet: {
+			type: Boolean,
+			default: false,
+		},
+		/**
+		 * Set the width to override aspect ratio driven and/or default dimensions
+		 */
+		width: {
+			type: Number,
+			default: null,
+		},
+		/**
+		 * Default zoom level
+		 */
+		zoomLevel: {
+			type: Number,
+			default: 4,
+		},
+	},
+	data() {
+		return {
+			hasWebGL: false,
+			leafletReady: false,
+			mapInstance: null,
+			mapLibreReady: false,
+			mapLoaded: false,
+			zoomActive: false,
+		};
+	},
+	computed: {
+		mapDimensions() {
+			// Use container to derive height based on aspect ration + width
+			const container = this.$el?.getBoundingClientRect();
+			const height = container ? `${container.width / this.aspectRatio}px` : '300px';
+			const width = container ? `${container.width}px` : '100%';
+			// Override values if deliberate height or width are provided
+			return {
+				height: this.height ? `${this.height}px` : height,
+				width: this.width ? `${this.width}px` : width,
+				paddingBottom: this.height ? `${this.height}px` : `${100 / this.aspectRatio}%`,
+			};
+		},
+		refString() {
+			return `mapholder${this.mapId}`;
+		},
+	},
+	watch: {
+		lat(next, prev) {
+			if (prev === null && this.long && !this.mapLibreReady && !this.leafletReady) {
+				this.initializeMap();
+			}
+		},
+		long(next, prev) {
+			if (prev === null && this.lat && !this.mapLibreReady && !this.leafletReady) {
+				this.initializeMap();
+			}
+		},
+	},
+	mounted() {
+		if (!this.mapLibreReady && !this.leafletReady) {
+			this.initializeMap();
+		}
+	},
+	beforeDestroy() {
+		if (this.mapInstance) {
+			if (!this.hasWebGL && !this.leafletReady) {
+				// turn off the leaflet instance
+				this.mapInstance.off();
+			}
+			// remove either leaflet or maplibregl
+			this.mapInstance.remove();
+		}
+		this.destroyWrapperObserver();
+	},
+	methods: {
+		activateZoom(zoomOut = false) {
+			const { mapInstance, hasWebGL, mapLibreReady } = this;
+			const currentZoomLevel = mapInstance.getZoom();
+			// exit if already zoomed in (getZoom() works for both leaflet + maplibregl)
+			if ((!zoomOut && currentZoomLevel === this.zoomLevel)
+				|| (zoomOut && currentZoomLevel === this.initialZoom)) return false;
+
+			this.zoomActive = true;
+			// establish delayed zoom duration
+			const timedZoom = window.setTimeout(() => {
+				if (hasWebGL && mapLibreReady) {
+					// maplibregl specific zoom method
+					mapInstance.zoomTo(
+						zoomOut ? this.initialZoom : this.zoomLevel,
+						{ duration: 1200 },
+					);
+				} else {
+					// leaflet specific zoom method
+					mapInstance.setZoom(zoomOut ? this.initialZoom : this.zoomLevel);
+				}
+
+				clearTimeout(timedZoom);
+				this.zoomActive = false;
+			}, this.autoZoomDelay);
+		},
+		createWrapperObserver() {
+			// Watch for the wrapper element moving in and out of the viewport
+			this.wrapperObserver = this.createIntersectionObserver({
+				targets: [this.$refs?.[this.refString]],
+				callback: (entries) => {
+					entries.forEach((entry) => {
+						if (entry.target === this.$refs?.[this.refString] && !this.zoomActive) {
+							if (entry.intersectionRatio > 0) {
+								this.activateZoom();
+							}
+						}
+					});
+				},
+			});
+		},
+		destroyWrapperObserver() {
+			if (this.wrapperObserver) {
+				this.wrapperObserver.disconnect();
+			}
+		},
+		checkWebGL() {
+			// exit and use leaflet if specified or document isn't present
+			if (this.useLeaflet || typeof document === 'undefined') return false;
+			// via. https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/By_example/Detect_WebGL
+			// Create canvas element. The canvas is not added to the document itself,
+			// so it is never displayed in the browser window.
+			const canvas = document.createElement('canvas');
+			// Get WebGLRenderingContext from canvas element.
+			const gl = canvas.getContext('webgl')
+			|| canvas.getContext('experimental-webgl');
+			// Report the result.
+			if (gl && gl instanceof WebGLRenderingContext) {
+				this.hasWebGL = true;
+				return true;
+			}
+			return false;
+		},
+		initializeMap() {
+			/**
+			 * This initial checkWebGL() call kicks off the library asset inclusion
+			 * We then start polling for the readiness of our selected map library and initialize it once ready
+			 */
+			const mapScript = document.createElement('script');
+			const mapStyle = document.createElement('link');
+			mapScript.setAttribute('async', true);
+			mapScript.setAttribute('defer', true);
+			mapStyle.setAttribute('rel', 'stylesheet');
+			if (this.checkWebGL()) {
+				mapScript.setAttribute('vmid', `maplibregljs${this.mapId}`);
+				mapStyle.setAttribute('vmid', `maplibreglcss${this.mapId}`);
+				mapScript.setAttribute('src', 'https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.js');
+				mapStyle.setAttribute('href', 'https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.css');
+
+				this.testDelayedGlobalLibrary('maplibregl').then((response) => {
+					if (response.loaded && !this.mapLoaded && !this.useLeaflet && this.lat && this.long) {
+						this.initializeMapLibre();
+						this.mapLibreReady = true;
+					}
+				});
+			} else {
+				mapScript.setAttribute('vmid', `leafletjs${this.mapId}`);
+				mapStyle.setAttribute('vmid', `leaftletcss${this.mapId}`);
+				mapScript.setAttribute('src', 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.js');
+				mapStyle.setAttribute('href', 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.css');
+
+				this.testDelayedGlobalLibrary('L').then((leafletTest) => {
+					if (leafletTest.loaded && !this.mapLoaded && this.lat && this.long) {
+						this.initializeLeaflet();
+						this.leafletReady = true;
+					}
+				});
+			}
+			document.head.appendChild(mapScript);
+			document.head.appendChild(mapStyle);
+		},
+		initializeLeaflet() {
+			/* eslint-disable no-undef, max-len */
+			// Initialize primary mapInstance
+			this.mapInstance = L.map(`kv-map-holder-${this.mapId}`, {
+				center: [this.lat, this.long],
+				zoom: this.initialZoom || this.zoomLevel,
+				// todo make props for the following options
+				dragging: false,
+				zoomControl: false,
+				animate: true,
+				scrollWheelZoom: false,
+				doubleClickZoom: false,
+				attributionControl: false,
+			});
+			/* eslint-disable quotes */
+			// Add our tileset to the mapInstance
+			L.tileLayer('https://api.maptiler.com/maps/bright/{z}/{x}/{y}.png?key=n1Mz5ziX3k6JfdjFe7mx', {
+				tileSize: 512,
+				zoomOffset: -1,
+				minZoom: 1,
+				crossOrigin: true,
+			}).addTo(this.mapInstance);
+			/* eslint-enable quotes */
+			/* eslint-enable no-undef, max-len */
+
+			// signify map has loaded
+			this.mapLoaded = true;
+			// only activate autoZoom if we have an initialZoom set
+			if (this.initialZoom !== null) {
+				this.createWrapperObserver();
+			}
+		},
+		initializeMapLibre() {
+			// Initialize primary mapInstance
+			// eslint-disable-next-line no-undef
+			this.mapInstance = new maplibregl.Map({
+				container: `kv-map-holder-${this.mapId}`,
+				style: 'https://api.maptiler.com/maps/bright/style.json?key=n1Mz5ziX3k6JfdjFe7mx',
+				center: [this.long, this.lat],
+				zoom: this.initialZoom || this.zoomLevel,
+				attributionControl: false,
+				dragPan: false,
+				scrollZoom: false,
+				doubleClickZoom: false,
+				dragRotate: false,
+			});
+
+			// signify map has loaded
+			this.mapLoaded = true;
+
+			// only activate autoZoom if we have an initialZoom set
+			if (this.initialZoom !== null) {
+				this.createWrapperObserver();
+			}
+		},
+		checkIntersectionObserverSupport() {
+			if (typeof window === 'undefined'
+				|| !('IntersectionObserver' in window)
+				|| !('IntersectionObserverEntry' in window)
+				|| !('intersectionRatio' in window.IntersectionObserverEntry.prototype)) {
+				return false;
+			}
+			return true;
+		},
+		createIntersectionObserver({ callback, options, targets } = {}) {
+			if (this.checkIntersectionObserverSupport()) {
+				const observer = new IntersectionObserver(callback, options);
+				targets.forEach((target) => observer.observe(target));
+				return observer;
+			}
+		},
+		testDelayedGlobalLibrary(library, timeout = 3000) {
+			// return a promise
+			return new Promise((resolve, reject) => {
+				if (typeof window === 'undefined') {
+					reject(new Error('window object not available'));
+				}
+				// establish timeout to limit time until promise resolution
+				let readyStateTimeout;
+				// establish interval to check for library presence
+				const readyStateInterval = window.setInterval(() => {
+					// determine if library is present on window
+					if (typeof window[library] !== 'undefined') {
+						// cleanup timers
+						clearInterval(readyStateInterval);
+						clearTimeout(readyStateTimeout);
+						// resolve the promise
+						resolve({ loaded: true });
+					}
+				}, 100);
+
+				// activate timeout
+				readyStateTimeout = window.setTimeout(() => {
+					// clean up interval and timeout
+					clearInterval(readyStateInterval);
+					clearTimeout(readyStateTimeout);
+					// resolve the promise
+					resolve({ loaded: false });
+				}, timeout);
+			});
+		},
+	},
+};
+</script>

package/vue/stories/KvMap.stories.js

@@ -0,0 +1,69 @@
+import KvMap from '../KvMap.vue';
+
+export default {
+	title: 'KvMap',
+	component: KvMap,
+	args: {
+		autoZoomDelay: 1000,
+		height: null,
+		initialZoom: null,
+		lat: 37.700091,
+		long: -123.013243,
+		mapId: 0,
+		useLeaflet: false,
+		width: null,
+		zoomLevel: 4,
+	},
+};
+
+const Template = (args, { argTypes }) => ({
+	props: Object.keys(argTypes),
+	components: { KvMap },
+	template: `<kv-map
+		class="tw-rounded tw-overflow-hidden"
+		:auto-zoom-delay="autoZoomDelay"
+		:height="height"
+		:lat="lat"
+		:long="long"
+		:initial-zoom="initialZoom"
+		:map-id="mapId"
+		:use-leaflet="useLeaflet"
+		:width="width"
+		:zoom-level="zoomLevel"
+	/>`,
+});
+
+export const Default = Template.bind({});
+Default.args = {
+	initialZoom: null,
+	mapId: 1,
+	zoomLevel: 14,
+};
+
+export const AutoZoom = Template.bind({});
+AutoZoom.args = {
+	initialZoom: 1,
+	lat: -0.023559,
+	long: 37.906193,
+	mapId: 2,
+	zoomLevel: 4,
+};
+
+export const FixedDimensions = Template.bind({});
+FixedDimensions.args = {
+	initialZoom: null,
+	height: 250,
+	mapId: 3,
+	width: 250,
+	zoomLevel: 14,
+};
+
+export const Leaflet = Template.bind({});
+Leaflet.args = {
+	initialZoom: null,
+	lat: -0.023559,
+	long: 37.906193,
+	mapId: 4,
+	useLeaflet: true,
+	zoomLevel: 6,
+};