maplibre-gl-js-amplify
Version:
MapLibre Plugin to Support Amplify Geo Integration
404 lines (403 loc) • 22.9 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AmplifyGeofenceControlUI = void 0;
const debounce_1 = require("debounce");
const utils_1 = require("../utils");
const icons_1 = require("./icons");
const icons_2 = require("./icons");
function AmplifyGeofenceControlUI(geofenceControl, geofenceControlContainer) {
let _addGeofenceContainer;
let _deleteGeofenceContainer;
let _addGeofencebutton;
let _checkboxAll;
let _geofenceList;
let _createContainer;
let _geofenceTitle;
let _checkBoxAllAndCreateContainer;
let _checkBoxAllContainer;
let _circleModeContainer;
let _polygonModeContainer;
let _deletePopdownContainer;
let _errorDiv;
let _geofenceCreateRadiusInput;
function registerControlPosition(map, positionName) {
if (map._controlPositions[positionName]) {
return;
}
const positionContainer = document.createElement('div');
positionContainer.className = `maplibregl-ctrl-${positionName}`;
map._controlContainer.appendChild(positionContainer);
map._controlPositions[positionName] = positionContainer;
}
/************************************************************
* Create Geofence Controls
*************************************************************/
function createGeofenceCreateContainer(isCircle) {
const container = (0, utils_1.createElement)('div', 'geofence-ctrl-create-prompt-container', geofenceControlContainer);
_createContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-create-prompt', container);
if (isCircle) {
/* Create buttons to switch between different modes */
const buttonContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-create-prompt-buttons', _createContainer);
const circleModeButton = (0, utils_1.createElement)('div', 'geofence-ctrl-create-prompt-button-circle geofence-ctrl-create-prompt-button', buttonContainer);
circleModeButton.addEventListener('click', () => {
// Change button selected style
circleModeButton.classList.add('geofence-ctrl-create-prompt-selected');
polygonModeButton.classList.remove('geofence-ctrl-create-prompt-selected');
// Switch info box mode
if (_polygonModeContainer) {
(0, utils_1.removeElement)(_polygonModeContainer);
_polygonModeContainer = undefined;
}
if (!_circleModeContainer)
createCircleModeCreateContainer(_createContainer);
geofenceControl.changeMode('draw_circle');
});
circleModeButton.innerHTML = 'Circle';
const polygonModeButton = (0, utils_1.createElement)('div', 'geofence-ctrl-create-prompt-button-polygon geofence-ctrl-create-prompt-button', buttonContainer);
polygonModeButton.addEventListener('click', () => {
geofenceControl.changeMode('draw_polygon');
// Change button selected style
polygonModeButton.classList.add('geofence-ctrl-create-prompt-selected');
circleModeButton.classList.remove('geofence-ctrl-create-prompt-selected');
// Switch info box mode
if (_circleModeContainer) {
(0, utils_1.removeElement)(_circleModeContainer);
_circleModeContainer = undefined;
}
if (!_polygonModeContainer)
createPolygonModeCreateContainer(_createContainer);
});
polygonModeButton.innerHTML = 'Custom';
circleModeButton.classList.add('geofence-ctrl-create-prompt-selected');
createCircleModeCreateContainer(_createContainer);
}
else {
createPolygonModeCreateContainer(_createContainer);
}
}
function createCircleModeCreateContainer(container) {
_circleModeContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-create-circle-mode-container', container);
const radiusTitle = (0, utils_1.createElement)('div', 'geofence-ctrl-create-circle-mode-title', _circleModeContainer);
radiusTitle.innerHTML = 'Radius';
_geofenceCreateRadiusInput = (0, utils_1.createElement)('input', 'geofence-ctrl-create-circle-mode-input', _circleModeContainer);
_geofenceCreateRadiusInput.addEventListener('keydown', (0, debounce_1.debounce)(geofenceControl.updateInputRadius, 200));
}
function createPolygonModeCreateContainer(container) {
_polygonModeContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-container', container);
const moreInfoContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-info-container', _polygonModeContainer);
const moreInfoIcon = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-icon', moreInfoContainer);
const letterI = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-info-icon', moreInfoIcon);
letterI.innerHTML = 'i';
const moreInfo = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-title', moreInfoContainer);
moreInfo.innerHTML = 'How it works?';
const resetButton = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-reset-button geofence-ctrl-button', _polygonModeContainer);
resetButton.innerHTML = 'Reset';
resetButton.addEventListener('click', () => {
geofenceControl.resetGeofence();
});
// Add popup onClick
const popup = createPolygonModeInfoPopup(moreInfoIcon);
moreInfoContainer.addEventListener('click', () => {
popup.classList.toggle('show');
});
}
function createPolygonModeInfoPopup(container) {
const popupContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-popup-container', container);
const popup = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-popup', popupContainer);
createPopupStep(popup, 'Move dots to desired position', (0, icons_2.createPopupStep1Icon)());
createPopupStep(popup, 'Click on a border to create a dot', (0, icons_2.createPopupStep2Icon)());
createPopupStep(popup, 'Click into shape to move', (0, icons_2.createPopupStep3Icon)());
createPopupStep(popup, 'Press delete to remove a dot', (0, icons_2.createPopupStep4Icon)());
return popup;
}
function createPopupStep(container, text, image) {
const popupStep = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-popup-step', container);
const popupStepImage = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-popup-step-image', popupStep);
popupStepImage.appendChild(image);
const popupStepText = (0, utils_1.createElement)('div', 'geofence-ctrl-create-polygon-mode-popup-step-text', popupStep);
popupStepText.innerHTML = text;
}
function removeGeofenceCreateContainer() {
(0, utils_1.removeElement)(_createContainer);
_createContainer = undefined;
_circleModeContainer = undefined;
_polygonModeContainer = undefined;
}
/************************************************************
* Geofence List
*************************************************************/
function createGeofenceListContainer() {
const geofenceListContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-list-container', geofenceControlContainer);
createGeofenceListHeader(geofenceListContainer);
_geofenceList = (0, utils_1.createElement)('div', 'geofence-ctrl-list', geofenceListContainer);
_geofenceList.addEventListener('scroll', () => {
const { scrollHeight, scrollTop, clientHeight } = _geofenceList;
if (scrollTop + clientHeight >= scrollHeight - 20) {
geofenceControl.loadMoreGeofences();
}
});
}
function createGeofenceListHeader(geofenceListContainer) {
const header = (0, utils_1.createElement)('div', 'geofence-ctrl-list-header', geofenceListContainer);
_geofenceTitle = (0, utils_1.createElement)('div', 'geofence-ctrl-list-header-title', header);
_geofenceTitle.innerHTML = 'Geofences (0)';
_checkBoxAllAndCreateContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-list-header-checkbox-create-container', header);
createCheckboxAllContainer(_checkBoxAllAndCreateContainer);
}
function createCheckboxAllContainer(geofenceListContainer) {
_checkBoxAllContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-list-checkbox-all-container', geofenceListContainer);
_checkboxAll = (0, utils_1.createElement)('input', 'geofence-ctrl-list-checkbox-all', _checkBoxAllContainer);
_checkboxAll.type = 'checkbox';
_checkboxAll.addEventListener('click', function () {
if (_checkboxAll.checked) {
geofenceControl.displayAllGeofences();
checkboxAllText.innerHTML = 'Deselect All';
}
else {
geofenceControl.hideAllGeofences();
checkboxAllText.innerHTML = 'Select All';
}
});
const checkboxAllText = (0, utils_1.createElement)('div', 'geofence-ctrl-list-checkbox-all-title', _checkBoxAllContainer);
checkboxAllText.innerHTML = 'Select all';
_addGeofencebutton = (0, utils_1.createElement)('div', 'geofence-ctrl-list-header-add-button', _checkBoxAllContainer);
_addGeofencebutton.innerHTML = '+ Add';
_addGeofencebutton.addEventListener('click', () => {
createAddGeofenceContainer();
});
}
function renderListItem(geofence) {
const container = (0, utils_1.createElement)('li', 'geofence-ctrl-list-item-container', _geofenceList);
container.id = `list-item-${geofence.geofenceId}`;
const listItem = (0, utils_1.createElement)('li', 'geofence-ctrl-list-item', container);
const leftContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-list-item-left-container', listItem);
const checkbox = (0, utils_1.createElement)('input', 'geofence-ctrl-list-item-checkbox', leftContainer);
checkbox.id = `list-item-checkbox-${geofence.geofenceId}`;
checkbox.type = 'checkbox';
checkbox.addEventListener('click', function () {
if (checkbox.checked) {
geofenceControl.displayGeofence(geofence.geofenceId);
geofenceControl.fitGeofence(geofence.geofenceId);
}
else {
geofenceControl.hideGeofence(geofence.geofenceId);
}
});
const rightContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-list-item-right-container', listItem);
const geofenceTitleContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-list-item-title-container', rightContainer);
geofenceTitleContainer.addEventListener('mouseover', function () {
geofenceControl.displayHighlightedGeofence(geofence.geofenceId);
});
geofenceTitleContainer.addEventListener('mouseout', function () {
geofenceControl.hideHighlightedGeofence();
});
const geofenceTitle = (0, utils_1.createElement)('div', 'geofence-ctrl-list-item-title', geofenceTitleContainer);
geofenceTitle.innerHTML = geofence.geofenceId;
const editButton = (0, utils_1.createElement)('div', 'geofence-ctrl-edit-button', geofenceTitleContainer);
editButton.addEventListener('click', function () {
geofenceControl.editGeofence(geofence.geofenceId);
createEditControls(listItem, rightContainer, leftContainer, geofence.geofenceId);
listItem.classList.remove('geofence-ctrl-list-item');
listItem.classList.add('geofence-ctrl-list-selected-item');
});
editButton.appendChild((0, icons_2.createEditIcon)());
}
function createEditControls(item, rightContainer, leftContainer, id) {
const editContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-list-item-controls', rightContainer);
const deleteButton = renderDeleteButton(leftContainer, id);
const removeEditContainer = () => {
item.classList.remove('geofence-ctrl-list-selected-item');
item.classList.add('geofence-ctrl-list-item');
(0, utils_1.removeElement)(editContainer);
(0, utils_1.removeElement)(deleteButton);
};
const cancelButton = (0, utils_1.createElement)('div', 'geofence-ctrl-cancel-button', editContainer);
cancelButton.classList.add('geofence-ctrl-button');
cancelButton.innerHTML = 'Cancel';
cancelButton.addEventListener('click', () => {
geofenceControl.setEditingModeEnabled(false);
removeEditContainer();
});
const saveGeofenceButton = (0, utils_1.createElement)('div', 'geofence-ctrl-save-button geofence-ctrl-button', editContainer);
saveGeofenceButton.addEventListener('click', () => __awaiter(this, void 0, void 0, function* () {
yield geofenceControl.saveGeofence();
removeEditContainer();
}));
saveGeofenceButton.title = 'Save';
saveGeofenceButton.innerHTML = 'Save';
}
/************************************************************
* Add Geofence Controls
*************************************************************/
function removeAddGeofenceContainer() {
(0, utils_1.removeElement)(_addGeofenceContainer);
clearAddGeofenceError();
showCheckboxAllContainer();
}
function clearAddGeofenceError() {
if (_errorDiv) {
(0, utils_1.removeElement)(_errorDiv);
_errorDiv = undefined;
}
}
function createAddGeofenceContainer() {
hideCheckboxAllContainer();
_addGeofenceContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-add-geofence-container', _checkBoxAllAndCreateContainer);
const addGeofencePrompt = (0, utils_1.createElement)('div', 'geofence-ctrl-add-geofence', _addGeofenceContainer);
const nameInput = (0, utils_1.createElement)('input', 'geofence-ctrl-add-geofence-input', addGeofencePrompt);
nameInput.placeholder = 'Enter name';
const buttonContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-add-geofence-buttons', addGeofencePrompt);
const cancelButton = (0, utils_1.createElement)('div', 'geofence-ctrl-add-geofence-cancel-button geofence-ctrl-button ', buttonContainer);
cancelButton.innerHTML = 'Cancel';
cancelButton.addEventListener('click', () => {
removeAddGeofenceContainer();
geofenceControl.setEditingModeEnabled(false);
});
const saveButton = (0, utils_1.createElement)('div', 'geofence-ctrl-button geofence-ctrl-save-button', buttonContainer);
saveButton.innerHTML = 'Save';
saveButton.addEventListener('click', function () {
return __awaiter(this, void 0, void 0, function* () {
clearAddGeofenceError();
const output = yield geofenceControl.createGeofence(escape(nameInput.value));
if (output)
removeAddGeofenceContainer();
});
});
geofenceControl.addEditableGeofence();
}
function createAddGeofencePromptError(error) {
if (_errorDiv) {
return;
}
_errorDiv = (0, utils_1.createElement)('div', 'geofence-ctrl-add-geofence-error', _addGeofenceContainer);
const errorIconContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-add-geofence-error-icon', _errorDiv);
errorIconContainer.appendChild((0, icons_1.createErrorIcon)());
const errorText = (0, utils_1.createElement)('div', 'geofence-ctrl-add-geofence-error-text', _errorDiv);
errorText.innerHTML = error;
}
/************************************************************
* Delete Controls
*************************************************************/
function renderDeleteButton(container, id) {
const deleteButton = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-button', container);
deleteButton.classList.add('geofence-ctrl-button');
deleteButton.addEventListener('click', function () {
createConfirmDeleteContainer(id);
});
deleteButton.appendChild((0, icons_2.createTrashIcon)());
return deleteButton;
}
function createConfirmDeleteContainer(geofenceId) {
_deleteGeofenceContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-prompt-container', geofenceControlContainer);
const deleteGeofencePrompt = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-prompt', _deleteGeofenceContainer);
const title = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-geofence-title', deleteGeofencePrompt);
title.innerHTML = `Are you sure you want to delete <strong>${geofenceId}</strong>?`;
createDeleteButtonsContainer(deleteGeofencePrompt, geofenceId);
}
function createDeleteButtonsContainer(container, geofenceId) {
const deleteButtonsContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-geofence-buttons', container);
const cancelButton = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-geofence-cancel-button', deleteButtonsContainer);
cancelButton.innerHTML = 'Cancel';
cancelButton.addEventListener('click', () => {
(0, utils_1.removeElement)(_deleteGeofenceContainer);
});
const confirmDeleteButton = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-geofence-confirm-button', deleteButtonsContainer);
confirmDeleteButton.innerHTML = 'Delete';
confirmDeleteButton.addEventListener('click', function () {
return __awaiter(this, void 0, void 0, function* () {
const id = yield geofenceControl.deleteGeofence(geofenceId);
if (id) {
createDeleteResultContainer(true);
(0, utils_1.removeElement)(_deleteGeofenceContainer);
geofenceControl.setEditingModeEnabled(false);
}
});
});
}
function createDeleteResultContainer(success) {
_deletePopdownContainer = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-popdown-container', geofenceControlContainer);
const deletePopdown = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-popdown', _deletePopdownContainer);
const deletePopdownCloseButton = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-popdown-close-button', _deletePopdownContainer);
deletePopdownCloseButton.appendChild((0, icons_2.createCloseIcon)());
deletePopdownCloseButton.addEventListener('click', () => {
(0, utils_1.removeElement)(_deletePopdownContainer);
});
const deleteSuccessIcon = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-popdown-icon', deletePopdown);
deleteSuccessIcon.appendChild((0, icons_2.createDeleteSuccessIcon)());
const deletePopdownText = (0, utils_1.createElement)('div', 'geofence-ctrl-delete-popdown-text', deletePopdown);
deletePopdownText.innerHTML = success
? 'Geofence was deleted successfully'
: 'Geofence failed to delete';
}
/************************************************************
* Utility Methods
*************************************************************/
function updateCheckbox(geofenceId, checked) {
const checkbox = document.getElementById(`list-item-checkbox-${geofenceId}`);
if (checkbox)
checkbox.checked = checked;
}
function removeGeofenceListItem(geofenceId) {
const listItem = document.getElementById(`list-item-${geofenceId}`);
(0, utils_1.removeElement)(listItem);
}
function setGeofenceListEnabled(enabled) {
_checkboxAll.disabled = !enabled;
enabled
? _addGeofencebutton.classList.remove('geofence-ctrl-noHover')
: _addGeofencebutton.classList.add('geofence-ctrl-noHover');
const inputs = document.getElementsByClassName('geofence-ctrl-list-item-checkbox');
for (let i = 0; i < inputs.length; i++) {
inputs.item(i).disabled = !enabled;
}
const items = document.getElementsByClassName('geofence-ctrl-list-item-container');
for (let i = 0; i < items.length; i++) {
enabled
? items.item(i).classList.remove('geofence-ctrl-noHover')
: items.item(i).classList.add('geofence-ctrl-noHover');
}
}
function getCheckboxAllValue() {
return _checkboxAll.checked;
}
function updateGeofenceCount(count) {
_geofenceTitle.innerHTML = `Geofences (${count})`;
}
function updateGeofenceRadius(radius) {
if (_geofenceCreateRadiusInput)
_geofenceCreateRadiusInput.value = `${radius}`;
}
function hideCheckboxAllContainer() {
_checkBoxAllContainer.style.display = 'none';
}
function showCheckboxAllContainer() {
_checkBoxAllContainer.style.display = 'flex';
}
return {
registerControlPosition,
createElement: utils_1.createElement,
removeElement: utils_1.removeElement,
createGeofenceCreateContainer,
createGeofenceListContainer,
removeAddGeofenceContainer,
createAddGeofencePromptError,
renderListItem,
updateCheckbox,
removeGeofenceListItem,
setGeofenceListEnabled,
getCheckboxAllValue,
removeGeofenceCreateContainer,
updateGeofenceCount,
updateGeofenceRadius,
};
}
exports.AmplifyGeofenceControlUI = AmplifyGeofenceControlUI;