☰

WME Places Name Normalizer

Normaliza nombres de lugares en Waze Map Editor (WME) por ahora solo con reglas de Colombia

目前为 2025-03-25 提交的版本。查看 最新版本。

  1. // ==UserScript==
  2. // @name         WME Places Name Normalizer
  3. // @namespace    https://gf.qytechs.cn/en/users/mincho77
  4. // @version      1.6.2
  5. // @description  Normaliza nombres de lugares en Waze Map Editor (WME) por ahora solo con reglas de Colombia
  6. // @author       mincho77
  7. // @match        https://www.waze.com/*editor*
  8. // @grant        GM_xmlhttpRequest
  9. // @grant        unsafeWindow
  10. // @license      MIT
  11. // @run-at       document-end
  12. // ==/UserScript==
  13. /*global W*/
  14.  
  15.  
  16. (() => {
  17.     "use strict";
  18.     if (!Array.prototype.flat) {
  19.         Array.prototype.flat = function(depth = 1) {
  20.             return this.reduce(function (flat, toFlatten) {
  21.                 return flat.concat(Array.isArray(toFlatten) ? toFlatten.flat(depth - 1) : toFlatten);
  22.             }, []);
  23.         };
  24.     }
  25.  
  26.     const SCRIPT_NAME = "PlacesNameNormalizer";
  27.     const VERSION = "1.6.2";
  28.     let placesToNormalize = [];
  29.     let excludeWords = JSON.parse(localStorage.getItem("excludeWords")) || ["EDS", "IPS", "McDonald's", "EPS"];
  30.     let maxPlaces = 50;
  31.     let normalizeArticles = true;
  32.     
  33.     // Expresión regular para detectar siglas (por ejemplo, "S.a.s", "L.T.D.A")
  34.     const siglaRegex = /^[A-Za-z](\.[A-Za-z])+\.?$/;
  35.  
  36.  
  37.  
  38.    function checkSpelling(text) {
  39.   return new Promise((resolve, reject) => {
  40.     GM_xmlhttpRequest({
  41.       method: "POST",
  42.       url: "https://api.languagetool.org/v2/check",
  43.       data: `text=${encodeURIComponent(text)}&language=es`,
  44.       headers: {
  45.         "Content-Type": "application/x-www-form-urlencoded"
  46.       },
  47.       onload: function(response) {
  48.         if (response.status === 200) {
  49.           try {
  50.             const data = JSON.parse(response.responseText);
  51.             resolve(data);
  52.           } catch (err) {
  53.             reject(err);
  54.           }
  55.         } else {
  56.           reject(`Error HTTP: ${response.status}`);
  57.         }
  58.       },
  59.       onerror: function(err) {
  60.         reject(err);
  61.       }
  62.     });
  63.   });
  64. }
  65.  
  66.     function applySpellCorrection(text) {
  67.         return checkSpelling(text).then(data => {
  68.             let corrected = text;
  69.             // Ordenar los matches de mayor a menor offset
  70.             const matches = data.matches.sort((a, b) => b.offset - a.offset);
  71.             matches.forEach(match => {
  72.                 if (match.replacements && match.replacements.length > 0) {
  73.                     const replacement = match.replacements[0].value;
  74.                     corrected = corrected.substring(0, match.offset) + replacement + corrected.substring(match.offset + match.length);
  75.                 }
  76.             });
  77.             return corrected;
  78.         });
  79.     }
  80.  
  81.  
  82.  
  83.     
  84.  
  85.     function createSidebarTab() {
  86.         const { tabLabel, tabPane } = W.userscripts.registerSidebarTab("PlacesNormalizer");
  87.  
  88.         if (!tabPane) {
  89.             console.error(`[${SCRIPT_NAME}] Error: No se pudo registrar el sidebar tab.`);
  90.             return;
  91.         }
  92.  
  93.         tabLabel.innerText = "Normalizer";
  94.         tabLabel.title = "Places Name Normalizer";
  95.         tabPane.innerHTML = getSidebarHTML();
  96.  
  97.         setTimeout(() => {
  98.             // Llamar a la función para esperar el DOM antes de ejecutar eventos
  99.             waitForDOM("#normalizer-tab", attachEvents);
  100.             //attachEvents();
  101.         }, 500);
  102.     }
  103.  
  104.  
  105.     function waitForDOM(selector, callback, interval = 500, maxAttempts = 10) {
  106.     let attempts = 0;
  107.     const checkExist = setInterval(() => {
  108.         const element = document.querySelector(selector);
  109.         if (element) {
  110.             clearInterval(checkExist);
  111.             callback(element);
  112.         } else if (attempts >= maxAttempts) {
  113.             clearInterval(checkExist);
  114.             console.error(`[${SCRIPT_NAME}] Error: No se encontraron elementos en el DOM después de ${maxAttempts} intentos.`);
  115.         }
  116.         attempts++;
  117.     }, interval);
  118. }
  119.  
  120.  
  121.     function getSidebarHTML() {
  122.     return `
  123.         <div id='normalizer-tab'>
  124.             <h4>Places Name Normalizer <span style='font-size:11px;'>v${VERSION}</span></h4>
  125.             <div>
  126.                 <input type="checkbox" id="normalizeArticles" ${normalizeArticles ? "checked" : ""}>
  127.                 <label for="normalizeArticles">No normalizar artículos (el, la, los, las)</label>
  128.             </div>
  129.            
  130.             <div>
  131.                 <label>Máximo de Places a buscar: </label>
  132.                 <input type='number' id='maxPlacesInput' value='${maxPlaces}' min='1' max='500' style='width: 60px;'>
  133.             </div>
  134.             <div>
  135.                 <label>Palabras Excluidas:</label>
  136.                 <input type='text' id='excludeWord' style='width: 120px;'>
  137.                 <button id='addExcludeWord'>Añadir</button>
  138.                 <ul id='excludeList'>${excludeWords.map(word => `<li>${word}</li>`).join('')}</ul>
  139.             </div>
  140.             <button id='scanPlaces' class='btn btn-primary'>Escanear</button>
  141.         </div>`;
  142. }
  143.  
  144.  
  145.     function attachEvents() {
  146.     console.log(`[${SCRIPT_NAME}] Adjuntando eventos...`);
  147.  
  148.     let normalizeArticlesCheckbox = document.getElementById("normalizeArticles");
  149.    
  150.     let maxPlacesInput = document.getElementById("maxPlacesInput");
  151.     let addExcludeWordButton = document.getElementById("addExcludeWord");
  152.     let scanPlacesButton = document.getElementById("scanPlaces");
  153.  
  154.     if (!normalizeArticlesCheckbox  || !maxPlacesInput || !addExcludeWordButton || !scanPlacesButton) {
  155.         console.error(`[${SCRIPT_NAME}] Error: No se encontraron elementos en el DOM.`);
  156.         return;
  157.     }
  158.  
  159.     normalizeArticlesCheckbox.addEventListener("change", (e) => {
  160.         normalizeArticles = e.target.checked;
  161.     });
  162.  
  163.   
  164.  
  165.     maxPlacesInput.addEventListener("input", (e) => {
  166.         maxPlaces = parseInt(e.target.value, 10);
  167.     });
  168.  
  169.     addExcludeWordButton.addEventListener("click", () => {
  170.         const wordInput = document.getElementById("excludeWord");
  171.         const word = wordInput.value.trim();
  172.         if (word && !excludeWords.includes(word)) {
  173.             excludeWords.push(word);
  174.             localStorage.setItem("excludeWords", JSON.stringify(excludeWords));
  175.             updateExcludeList();
  176.             wordInput.value = "";
  177.         }
  178.     });
  179.  
  180.     scanPlacesButton.addEventListener("click", scanPlaces);
  181. }
  182.  
  183.   
  184.     function updateExcludeList() {
  185.         const list = document.getElementById("excludeList");
  186.         list.innerHTML = excludeWords.map(word => `<li>${word}</li>`).join('');
  187.     }
  188.  
  189. function scanPlaces() {
  190.     const allPlaces = W.model.venues.getObjectArray();
  191.     console.log(`[${SCRIPT_NAME}] Iniciando escaneo de lugares...`);
  192.  
  193.     if (!W || !W.model || !W.model.venues || !W.model.venues.objects) {
  194.         console.error(`[${SCRIPT_NAME}] WME no está listo.`);
  195.         return;
  196.     }
  197.  
  198.     // Obtener el nivel del editor; si no existe, usamos Infinity para incluir todos.
  199.     let editorLevel = (W.model.user && typeof W.model.user.level === "number")
  200.         ? W.model.user.level
  201.         : Infinity;
  202.  
  203.     let places = Object.values(W.model.venues.objects);
  204.     console.log(`[${SCRIPT_NAME}] Total de lugares encontrados: ${places.length}`);
  205.  
  206.     if (places.length === 0) {
  207.         alert("No se encontraron Places en WME.");
  208.         return;
  209.     }
  210.  
  211. placesToNormalize = allPlaces
  212.   .filter(place =>
  213.     place &&
  214.     typeof place.getID === "function" &&
  215.     place.attributes &&
  216.     typeof place.attributes.name === "string"
  217.   )
  218.   .map(place => ({
  219.     id: place.getID(),
  220.     name: place.attributes.name,
  221.     attributes: place.attributes,
  222.     place: place
  223.   }));
  224.  
  225.  
  226.     // Luego se mapea y se sigue con el flujo habitual...
  227.     let placesMapped = placesToNormalize.map(place => {
  228.         let originalName = place.attributes.name;
  229.         let newName = normalizePlaceName(originalName);
  230.         return {
  231.             id: place.attributes.id,
  232.             originalName,
  233.             newName
  234.         };
  235.     });
  236.  
  237.     let filteredPlaces = placesMapped.filter(p =>
  238.         p.newName.trim() !== p.originalName.trim()
  239.     );
  240.  
  241.     console.log(`[${SCRIPT_NAME}] Lugares que cambiarán: ${filteredPlaces.length}`);
  242.  
  243.     if (filteredPlaces.length === 0) {
  244.         alert("No se encontraron Places que requieran cambio.");
  245.         return;
  246.     }
  247.  
  248.     openFloatingPanel(filteredPlaces);
  249. }
  250.  
  251.  
  252. function NameChangeAction(venue, oldName, newName) {
  253.     // Referencia al Place y los nombres
  254.     this.venue = venue;
  255.     this.oldName = oldName;
  256.     this.newName = newName;
  257.  
  258.     // ID único del Place
  259.     this.venueId = venue.attributes.id;
  260.  
  261.     // Metadatos que WME/Plugins pueden usar
  262.     this.type = "NameChangeAction";
  263.     this.isGeometryEdit = false; // no es una edición de geometría
  264. }
  265.  
  266. /**
  267.  * 1) getActionName: nombre de la acción en el historial.
  268.  */
  269. NameChangeAction.prototype.getActionName = function() {
  270.     return "Update place name";
  271. };
  272.  
  273. /** 2) getActionText: texto corto que WME a veces muestra. */
  274. NameChangeAction.prototype.getActionText = function() {
  275.     return "Update place name";
  276. };
  277.  
  278. /** 3) getName: algunas versiones llaman a getName(). */
  279. NameChangeAction.prototype.getName = function() {
  280.     return "Update place name";
  281. };
  282.  
  283. /** 4) getDescription: descripción detallada de la acción. */
  284. NameChangeAction.prototype.getDescription = function() {
  285.     return `Place name changed from "${this.oldName}" to "${this.newName}".`;
  286. };
  287.  
  288. /** 5) getT: título (a veces requerido por plugins). */
  289. NameChangeAction.prototype.getT = function() {
  290.     return "Update place name";
  291. };
  292.  
  293. /** 6) getID: si un plugin llama a e.getID(). */
  294. NameChangeAction.prototype.getID = function() {
  295.     return `NameChangeAction-${this.venueId}`;
  296. };
  297.  
  298. /** 7) doAction: asigna el nuevo nombre (WME llama a esto al crear la acción). */
  299. NameChangeAction.prototype.doAction = function() {
  300.     this.venue.attributes.name = this.newName;
  301.     this.venue.isDirty = true;
  302.     if (typeof W.model.venues.markObjectEdited === "function") {
  303.         W.model.venues.markObjectEdited(this.venue);
  304.     }
  305. };
  306.  
  307. /** 8) undoAction: revertir al nombre anterior (Ctrl+Z). */
  308. NameChangeAction.prototype.undoAction = function() {
  309.     this.venue.attributes.name = this.oldName;
  310.     this.venue.isDirty = true;
  311.     if (typeof W.model.venues.markObjectEdited === "function") {
  312.         W.model.venues.markObjectEdited(this.venue);
  313.     }
  314. };
  315.  
  316. /** 9) redoAction: rehacer (Ctrl+Shift+Z), vuelve a doAction. */
  317. NameChangeAction.prototype.redoAction = function() {
  318.     this.doAction();
  319. };
  320.  
  321. /** 10) undoSupported / redoSupported: indica si se puede des/rehacer. */
  322. NameChangeAction.prototype.undoSupported = function() {
  323.     return true;
  324. };
  325. NameChangeAction.prototype.redoSupported = function() {
  326.     return true;
  327. };
  328.  
  329. /** 11) accept / supersede: evita fusionar con otras acciones. */
  330. NameChangeAction.prototype.accept = function() {
  331.     return false;
  332. };
  333. NameChangeAction.prototype.supersede = function() {
  334.     return false;
  335. };
  336.  
  337. /** 12) isEditAction: true => habilita "Guardar". */
  338. NameChangeAction.prototype.isEditAction = function() {
  339.     return true;
  340. };
  341.  
  342. /** 13) getAffectedUniqueIds: objetos que se alteran. */
  343. NameChangeAction.prototype.getAffectedUniqueIds = function() {
  344.     return [this.venueId];
  345. };
  346.  
  347. /** 14) isSerializable: si no implementas serialize(), pon false. */
  348. NameChangeAction.prototype.isSerializable = function() {
  349.     return false;
  350. };
  351.  
  352. /** 15) isActionStackable: false => no combina con otras ediciones. */
  353. NameChangeAction.prototype.isActionStackable = function() {
  354.     return false;
  355. };
  356.  
  357. /** 16) getFocusFeatures: WME/Plugins pueden usarlo para "enfocar" el objeto. */
  358. NameChangeAction.prototype.getFocusFeatures = function() {
  359.     // Devolvemos el venue para indicar que ese es el foco (o un array vacío si prefieres).
  360.     return [this.venue];
  361. };
  362.  
  363. /** 17) Métodos vacíos para evitar futuros "no es una función" si WME pide estos. */
  364. NameChangeAction.prototype.getFocusSegments = function() {
  365.     return [];
  366. };
  367. NameChangeAction.prototype.getFocusNodes = function() {
  368.     return [];
  369. };
  370. NameChangeAction.prototype.getFocusClosures = function() {
  371.     return [];
  372. };
  373.  
  374. /** 18) getTimestamp: método nuevo que WME/Plugins están llamando. */
  375. NameChangeAction.prototype.getTimestamp = function() {
  376.     // Devolvemos un timestamp numérico (ms desde época UNIX).
  377.     return Date.now();
  378. };
  379.  
  380. function applyNormalization() {
  381.   const checkboxes = document.querySelectorAll(".normalize-checkbox:checked");
  382.   let changesMade = false;
  383.  
  384.   if (checkboxes.length === 0) {
  385.     console.log("ℹ️ No hay lugares seleccionados para normalizar.");
  386.     return;
  387.   }
  388.  
  389.   checkboxes.forEach(cb => {
  390.     const index = cb.dataset.index;
  391.     const input = document.querySelector(`.new-name-input[data-index="${index}"]`);
  392.     const newName = input?.value?.trim();
  393.     const placeId = input?.getAttribute("data-place-id");
  394.     const place = W.model.venues.getObjectById(placeId);
  395.  
  396.     if (!place || !place.attributes?.name) {
  397.       console.warn(`⛔ No se encontró el lugar con ID: ${placeId}`);
  398.       return;
  399.     }
  400.  
  401.     const currentName = place.attributes.name.trim();
  402.  
  403.     console.log(`🧠 Evaluando ID ${placeId}`);
  404.     console.log(`🔹 Actual en mapa: "${currentName}"`);
  405.     console.log(`🔸 Nuevo propuesto: "${newName}"`);
  406.  
  407.     if (currentName !== newName) {
  408.       try {
  409.         // Esta es la forma correcta para obtener UpdateObject en WME
  410.         const UpdateObject = require("Waze/Action/UpdateObject");
  411.         const action = new UpdateObject(place, { name: newName });
  412.         W.model.actionManager.add(action);
  413.         console.log(`✅ Acción aplicada: "${currentName}" → "${newName}"`);
  414.         changesMade = true;
  415.       } catch (error) {
  416.         console.error("⛔ Error aplicando la acción de actualización:", error);
  417.       }
  418.     } else {
  419.       console.log(`⏭ Sin cambios reales para ID ${placeId}`);
  420.     }
  421.   });
  422.  
  423.   if (changesMade) {
  424.     console.log("💾 Cambios marcados. Recuerda presionar el botón de guardar en el editor.");
  425.   } else {
  426.     console.log("ℹ️ No hubo cambios para aplicar.");
  427.   }
  428. }
  429.  
  430.  
  431. function normalizePlaceName(name) {
  432.   if (!name) return "";
  433.  
  434.   const siglaRegex = /^[A-Z](\.[A-Z])+\.?$/; // Ej: S.A.S, L.T.D.A, C.I., etc.
  435.  
  436.   const words = name.split(" ");
  437.  
  438.   const normalizedWords = words.map(word => {
  439.     // Detectar siglas tipo S.A.S o L.T.D.A
  440.     if (siglaRegex.test(word.toUpperCase())) {
  441.       return word.toUpperCase();
  442.     }
  443.  
  444.     // Capitalizar palabra normal (Title Case)
  445.     return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
  446.   });
  447.  
  448.   name = normalizedWords.join(" ");
  449.  
  450.   // Reemplazar pipes | por guiones con espacio
  451.   name = name.replace(/\s*\|\s*/g, " - ");
  452.  
  453.   // Limpiar espacios múltiples
  454.   name = name.replace(/\s{2,}/g, " ").trim();
  455.  
  456.   return name;
  457. }
  458.  
  459.  
  460. // ⬅️ Esta línea justo fuera de la función, no adentro
  461. //window.normalizePlaceName = normalizePlaceName;
  462.     // Para exponer al contexto global real desde Tampermonkey
  463. unsafeWindow.normalizePlaceName = normalizePlaceName;
  464.  
  465.  
  466.  
  467.  function openFloatingPanel(placesToNormalize) {
  468.     console.log(`[${SCRIPT_NAME}] Creando panel flotante...`);
  469.  
  470.     if (!placesToNormalize || placesToNormalize.length === 0) {
  471.         console.warn(`[${SCRIPT_NAME}] No hay lugares para normalizar.`);
  472.         return;
  473.     }
  474.  
  475.     // Elimina cualquier panel flotante previo
  476.     let existingPanel = document.getElementById("normalizer-floating-panel");
  477.     if (existingPanel) existingPanel.remove();
  478.  
  479.     // Crear el panel flotante
  480.     let panel = document.createElement("div");
  481.    panel.id = "normalizer-floating-panel";
  482.     panel.style.position = "fixed";
  483. panel.style.top = "100px";
  484. panel.style.left = "300px"; // deja espacio para la barra lateral
  485. panel.style.width = "calc(100vw - 400px)"; // margen adicional para que no se desborde
  486.     panel.style.maxWidth = "calc(100vw - 30px)";
  487. panel.style.zIndex = 10000;
  488. panel.style.backgroundColor = "white";
  489. panel.style.border = "1px solid #ccc";
  490. panel.style.padding = "15px";
  491. panel.style.boxShadow = "0 2px 10px rgba(0,0,0,0.3)";
  492. panel.style.borderRadius = "8px";
  493.  
  494.     // Contenido del panel
  495.       let panelContent = `
  496.     <h3 style="text-align: center;">Lugares para Normalizar</h3>
  497.     <div style="max-height: 60vh; overflow-y: auto; margin-bottom: 10px;">
  498.         <table style="width: 100%; border-collapse: collapse;">
  499.             <thead>
  500.                 <tr style="border-bottom: 2px solid black;">
  501.                     <th><input type="checkbox" id="selectAllCheckbox"></th>
  502.                     <th style="text-align: left;">Nombre Original</th>
  503.                     <th style="text-align: left;">Nuevo Nombre</th>
  504.                 </tr>
  505.             </thead>
  506.             <tbody>
  507.     `;
  508.  
  509.    placesToNormalize.forEach((place, index) => {
  510.     if (place && place.originalName) {
  511.         const originalName = place.originalName;
  512.         const newName = normalizePlaceName(originalName);
  513.  
  514.         const placeId = place.id;
  515.         panelContent += `
  516.             <tr>
  517.                 <td><input type="checkbox" class="normalize-checkbox" data-index="${index}" checked></td>
  518.                 <td>${originalName}</td>
  519.                 <td><input type="text" class="new-name-input" data-index="${index}" data-place-id="${place.id}" value="${newName}" style="width: 100%;"></td>
  520.             </tr>
  521.         `;
  522.     }
  523. });
  524.     panelContent += `</tbody></table>`;
  525.  
  526.     // Agregar botones al panel sin eventos inline
  527.    // Ejemplo de la sección de botones en panelContent:
  528.      panelContent += `
  529.     <button id="applyNormalizationBtn" style="margin-top: 10px; width: 100%; padding: 8px; background: #4CAF50; color: white; border: none; cursor: pointer;">
  530.         Aplicar Normalización
  531.     </button>
  532.     <button id="closeFloatingPanelBtn" style="margin-top: 5px; width: 100%; padding: 8px; background: #d9534f; color: white; border: none; cursor: pointer;">
  533.         Cerrar
  534.     </button>
  535.     <button id="checkSpellingBtn" style="margin-top: 5px; width: 100%; padding: 8px; background: #007BFF; color: white; border: none; cursor: pointer;">
  536.         Corregir Ortografía
  537.     </button>
  538. `;
  539.  
  540.     panel.innerHTML = panelContent;
  541.     document.body.appendChild(panel);
  542.  
  543.     // Evento para seleccionar todas las casillas
  544.     document.getElementById("selectAllCheckbox").addEventListener("change", function() {
  545.         let isChecked = this.checked;
  546.         document.querySelectorAll(".normalize-checkbox").forEach(checkbox => {
  547.             checkbox.checked = isChecked;
  548.         });
  549.     });
  550.  
  551.     // Evento para cerrar el panel (CORREGIDO)
  552.     document.getElementById("closeFloatingPanelBtn").addEventListener("click", function() {
  553.         let panel = document.getElementById("normalizer-floating-panel");
  554.         if (panel) panel.remove();
  555.     });
  556.      // Evento para corregir ortografía en cada input del panel:
  557. document.getElementById("checkSpellingBtn").addEventListener("click", function() {
  558.   const inputs = document.querySelectorAll(".new-name-input");
  559.   inputs.forEach(input => {
  560.     const text = input.value;
  561.     applySpellCorrection(text).then(corrected => {
  562.       input.value = corrected;
  563.     });
  564.   });
  565. });
  566.  
  567.     // Evento para aplicar normalización
  568.     document.getElementById("applyNormalizationBtn").addEventListener("click", function() {
  569.         let selectedPlaces = [];
  570.         document.querySelectorAll(".normalize-checkbox:checked").forEach(checkbox => {
  571.             let index = checkbox.getAttribute("data-index");
  572.             let newName = document.querySelector(`.new-name-input[data-index="${index}"]`).value;
  573.             selectedPlaces.push({ ...placesToNormalize[index], newName });
  574.         });
  575.  
  576.         if (selectedPlaces.length === 0) {
  577.             alert("No se ha seleccionado ningún lugar.");
  578.             return;
  579.         }
  580.  
  581.         applyNormalization(selectedPlaces);
  582.     });
  583. }
  584.  
  585.  
  586.     function waitForWME() {
  587.         if (W && W.userscripts && W.model && W.model.venues) {
  588.             console.log(`[${SCRIPT_NAME}] Inicializando v${VERSION}`);
  589.             createSidebarTab();
  590.         } else {
  591.             console.log(`[${SCRIPT_NAME}] Esperando que WME esté listo...`);
  592.             setTimeout(waitForWME, 1000);
  593.         }
  594.     }
  595.     console.log(window.applyNormalization);
  596. window.applyNormalization = applyNormalization;
  597.     waitForWME();
  598. })();

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址