decidim-core 0.23.2 → 0.24.0

data/app/assets/javascripts/decidim/editor/modified_backspace_utils.js.es6

@@ -0,0 +1,31 @@
+// ORGINAL: https://github.com/quilljs/delta/blob/ddda3bf088cda3ec03d5dbcc1179679d147f3a02/src/AttributeMap.ts
+
+((exports) => {
+  const attributeDiff = (attributes1, attributes2) => {
+    let alpha = attributes1;
+    let beta = attributes2;
+    if (typeof alpha !== "object") {
+      alpha = {};
+    }
+    if (typeof beta !== "object") {
+      beta = {};
+    }
+    const attributes = Object.keys(alpha).concat(Object.keys(beta)).reduce((attrs, key) => {
+      // ORGINAL: import isEqual from 'lodash.isequal'; if (!isEqual(a[key], b[key]))
+      if ((alpha[key] !== beta[key])) {
+        attrs[key] = null;
+        if (beta[key]) {
+          attrs[key] = beta[key]
+        }
+      }
+      return attrs;
+    }, {});
+
+    if (Object.keys(attributes).length > 0) {
+      return attributes;
+    }
+    return null;
+  }
+
+  exports.Decidim.Editor.attributeDiff = attributeDiff
+})(window)

data/app/assets/javascripts/decidim/editor/modified_enter.js.es6

@@ -0,0 +1,118 @@
+
+((exports) => {
+  const Quill = exports.Quill;
+  const Parchment = Quill.import("parchment")
+  const Delta = Quill.import("delta");
+
+  const getLineFormats = (context) => {
+    return Object.keys(context.format).reduce(
+      (formats, format) => {
+        // See Parchment registry.ts => (1 << 3) | ((1 << 2) - 1) = 8 | 3 = 11
+        const blockScope = 11;
+        if (
+          Parchment.query(format, blockScope) &&
+          !Array.isArray(context.format[format])
+        ) {
+          formats[format] = context.format[format];
+        }
+        return formats;
+      },
+      {},
+    );
+  }
+
+  const continueFormats = (quill, context, lineFormats) => {
+    Object.keys(context.format).forEach((name) => {
+      if (typeof lineFormats[name] !== "undefined" && lineFormats[name] !== null) {
+        return;
+      }
+      if (Array.isArray(context.format[name])) {
+        return;
+      }
+      if (name === "link") {
+        return;
+      }
+      quill.format(name, context.format[name], Quill.sources.USER);
+    });
+  }
+
+  const lineBreakHandler = (quill, range, context) => {
+    const currentLeaf = quill.getLeaf(range.index)[0];
+    const nextLeaf = quill.getLeaf(range.index + 1)[0];
+    const previousChar = quill.getText(range.index - 1, 1);
+
+    quill.insertEmbed(range.index, "break", true, "user");
+    quill.formatText(range.index + 1, "bold", true)
+    if (nextLeaf === null || (currentLeaf.parent !== nextLeaf.parent)) {
+      quill.insertEmbed(range.index, "break", true, "user");
+    } else if (context.offset === 1 && previousChar === "\n") {
+      const delta = new Delta().retain(range.index).insert("\n");
+      quill.updateContents(delta, Quill.sources.USER);
+    }
+
+    quill.format(name, context.format[name], Quill.sources.USER);
+    quill.setSelection(range.index + 1, Quill.sources.SILENT);
+
+    const lineFormats = getLineFormats(context);
+    continueFormats(quill, context, lineFormats);
+  };
+
+  const addEnterBindings = (quill) => {
+    quill.clipboard.addMatcher("BR", () => {
+      let newDelta = new Delta();
+      newDelta.insert({"break": ""});
+      return newDelta;
+    });
+
+    quill.keyboard.addBinding({
+      key: 13,
+      shiftKey: true
+    }, (range, context) => {
+      lineBreakHandler(quill, range, context);
+    });
+
+    // HAX: make our SHIFT+ENTER binding the second (first is added below) in order to override Quill defaults
+    quill.keyboard.bindings[13].unshift(quill.keyboard.bindings[13].pop());
+
+    quill.keyboard.addBinding({ key: 13, shiftKey: false }, (range, context) => {
+      const lineFormats = getLineFormats(context);
+      const previousChar = quill.getText(range.index - 1, 1);
+      const nextChar = quill.getText(range.index, 1);
+      const delta = new Delta().retain(range.index).insert("\n", lineFormats);
+      // const length = context.prefix.length;
+      if (previousChar === "" || previousChar === "\n") {
+        if (lineFormats.list && nextChar === "\n") {
+          if (quill.getLength() - range.index > 2) {
+            const endFormatDelta = new Delta().retain(range.index - 1).delete(1);
+            quill.updateContents(endFormatDelta, Quill.sources.USER);
+          } else {
+            // Delete empty list item and end the list
+            const endFormatDelta = new Delta().retain(range.index - 1).delete(1).retain(range.index).insert("\n");
+            quill.updateContents(endFormatDelta, Quill.sources.USER);
+            quill.setSelection(range.index + 1, Quill.sources.SILENT);
+          }
+        } else {
+          quill.updateContents(delta, Quill.sources.USER);
+          if (context.offset === 1 && previousChar === "\n") {
+            quill.setSelection(range.index + 1, Quill.sources.SILENT);
+          } else {
+            quill.setSelection(range.index + 2, Quill.sources.SILENT);
+          }
+        }
+      } else {
+        quill.updateContents(delta, Quill.sources.USER);
+        quill.setSelection(range.index + 1, Quill.sources.SILENT);
+      }
+      quill.focus();
+
+      continueFormats(quill, context, lineFormats);
+    });
+
+    // Replace the default enter handling because we have modified the break element
+    quill.keyboard.bindings[13].unshift(quill.keyboard.bindings[13].pop());
+    return;
+  }
+
+  exports.Decidim.Editor = exports.Decidim.Editor || {};
+  exports.Decidim.Editor.addEnterBindings = addEnterBindings;
+})(window)

data/app/assets/javascripts/decidim/form_filter.component.js.es6

@@ -1,4 +1,5 @@
 /* eslint-disable no-div-regex, no-useless-escape, no-param-reassign, id-length */
+/* eslint max-lines: ["error", {"max": 350, "skipBlankLines": true}] */
 
 /**
  * A plain Javascript component that handles the form filter.
@@ -47,7 +48,12 @@
     mountComponent() {
       if (this.$form.length > 0 && !this.mounted) {
         this.mounted = true;
+        let queue = 0;
 
+        let contentContainer = $(this.$form.closest(".filters").parent().find(".skip").attr("href"));
+        if (contentContainer.length === 0) {
+          contentContainer = this.$form.data("remoteFill");
+        }
         this.$form.on("change", "input:not([data-disable-dynamic-change]), select:not([data-disable-dynamic-change])", this._onFormChange);
 
         this.currentFormRequest = null;
@@ -56,6 +62,25 @@
             this.currentFormRequest.abort();
           }
           this.currentFormRequest = e.originalEvent.detail[0];
+          queue += 1;
+          if (queue > 0 && contentContainer.length > 0 && !contentContainer.hasClass("spinner-container")) {
+            contentContainer.addClass("spinner-container");
+          }
+        });
+
+        this.$form.on("ajax:success", () => {
+          queue -= 1;
+          if (queue <= 0 && contentContainer.length > 0) {
+            contentContainer.removeClass("spinner-container");
+          }
+        });
+
+        this.$form.on("ajax:error", () => {
+          queue -= 1;
+          if (queue <= 0 && contentContainer.length > 0) {
+            contentContainer.removeClass("spinner-container");
+          }
+          this.$form.find(".spinner-container").addClass("hide");
         });
 
         exports.theCheckBoxesTree.setContainerForm(this.$form);

data/app/assets/javascripts/decidim/gallery.js.es6

@@ -0,0 +1,5 @@
+$(() => {
+  $(".gallery__container").on("closed.zf.callout", (event) => {
+    $(event.target).remove();
+  });
+});

data/app/assets/javascripts/decidim/geocoding/attach_input.js.es6

@@ -83,22 +83,59 @@
       latitudeName: getCoordinateInputName("latitude", $input, attachOptions),
       longitudeName: getCoordinateInputName("longitude", $input, attachOptions)
     }, options);
+    let geocoded = false;
 
-    $input.on("geocoder-suggest-coordinates.decidim", (_ev, coordinates) => {
+    const createCoordinateFields = () => {
       let $latitude = $(`#${config.latitudeId}`);
-      let $longitude = $(`#${config.longitudeId}`);
       if ($latitude.length < 1) {
         $latitude = $(`<input type="hidden" name="${config.latitudeName}" id="${config.latitudeId}" />`);
         $input.after($latitude);
       }
+
+      let $longitude = $(`#${config.longitudeId}`);
       if ($longitude.length < 1) {
         $longitude = $(`<input type="hidden" name="${config.longitudeName}" id="${config.longitudeId}" />`);
         $input.after($longitude);
       }
+    }
+    const clearCoordinateFields = () => {
+      if (geocoded) {
+        return;
+      }
+
+      $(`#${config.latitudeId}`).val("").removeAttr("value");
+      $(`#${config.longitudeId}`).val("").removeAttr("value");
+    };
+    const setCoordinates = (coordinates) => {
+      createCoordinateFields();
 
-      $latitude.val(coordinates[0]).attr("value", coordinates[0]);
-      $longitude.val(coordinates[1]).attr("value", coordinates[1]);
+      $(`#${config.latitudeId}`).val(coordinates[0]).attr("value", coordinates[0]);
+      $(`#${config.longitudeId}`).val(coordinates[1]).attr("value", coordinates[1]);
+    }
+
+    // When the user changes the value of the coordinate field without selecting
+    // any of the geocoding autocomplete results, clear the current latitude and
+    // longitude values to let the backend do the geocoding. Once a geocoding
+    // autocomplete value has been selected, assume the user just wants to
+    // refine the address formatting without changing the location point value.
+    // If they want, they can still modify the point in the next step of the
+    // proposal creation/editing.
+    $input.on("change.decidim", () => {
+      clearCoordinateFields();
     });
+
+    // When we receive the geocoding event on the field, update the coordinate
+    // values.
+    $input.on("geocoder-suggest-coordinates.decidim", (_ev, coordinates) => {
+      setCoordinates(coordinates);
+      geocoded = true;
+    });
+
+    // Set the initial values if the field defines the coordinates
+    const coordinates = `${$input.data("coordinates")}`.split(",").map(parseFloat);
+    if (Array.isArray(coordinates) && coordinates.length === 2) {
+      setCoordinates(coordinates);
+    }
   };
 
   exports.Decidim = exports.Decidim || {};

data/app/assets/javascripts/decidim/input_character_counter.js.es6

@@ -98,8 +98,13 @@
     }
   }
 
+  const createCharacterCounter = ($input) => {
+    $input.data("remaining-characters-counter", new InputCharacterCounter($input));
+  }
+
   exports.Decidim = exports.Decidim || {};
   exports.Decidim.InputCharacterCounter = InputCharacterCounter;
+  exports.Decidim.createCharacterCounter = createCharacterCounter;
 
   exports.$(() => {
     exports.$("input[type='text'], textarea, .editor>input[type='hidden']").each((_i, elem) => {
@@ -109,7 +114,7 @@
         return;
       }
 
-      $input.data("remaining-characters-counter", new InputCharacterCounter($input));
+      createCharacterCounter($input);
     });
   });
 })(window);

data/app/assets/javascripts/decidim/map/controller/markers.js.es6

@@ -26,6 +26,11 @@
         $(`#${this.config.popupTemplateId}`).html()
       );
 
+      const updateCoordinates = (data) => {
+        $('input[data-type="latitude"]').val(data.lat);
+        $('input[data-type="longitude"]').val(data.lng);
+      };
+
       const bounds = new L.LatLngBounds(
         markersData.map(
           (markerData) => [markerData.latitude, markerData.longitude]
@@ -36,22 +41,47 @@
         let marker = L.marker([markerData.latitude, markerData.longitude], {
           icon: this.createIcon(),
           keyboard: true,
-          title: markerData.title
+          title: markerData.title,
+          draggable: markerData.draggable
         });
-        let node = document.createElement("div");
 
-        $.tmpl(this.config.popupTemplateId, markerData).appendTo(node);
-        marker.bindPopup(node, {
-          maxwidth: 640,
-          minWidth: 500,
-          keepInView: true,
-          className: "map-info"
-        }).openPopup();
+        if (markerData.draggable) {
+          updateCoordinates({
+            lat: markerData.latitude,
+            lng: markerData.longitude
+          });
+          marker.on("drag", (ev) => {
+            updateCoordinates(ev.target.getLatLng());
+          });
+        } else {
+          let node = document.createElement("div");
+
+          $.tmpl(this.config.popupTemplateId, markerData).appendTo(node);
+
+          marker.bindPopup(node, {
+            maxwidth: 640,
+            minWidth: 500,
+            keepInView: true,
+            className: "map-info"
+          }).openPopup();
+        }
 
         this.markerClusters.addLayer(marker);
       });
 
-      this.map.fitBounds(bounds, { padding: [100, 100] });
+      // Make sure there is enough space in the map for the padding to be
+      // applied. Otherwise the map will automatically zoom out (test it on
+      // mobile). Make sure there is at least the same amount of width and
+      // height available on both sides + the padding (i.e. 4x padding in
+      // total).
+      const size = this.map.getSize();
+      if (size.y >= 400 && size.x >= 400) {
+        this.map.fitBounds(bounds, { padding: [100, 100] });
+      } else if (size.y >= 120 && size.x >= 120) {
+        this.map.fitBounds(bounds, { padding: [30, 30] });
+      } else {
+        this.map.fitBounds(bounds);
+      }
     }
 
     clearMarkers() {

data/app/assets/javascripts/decidim/session_timeouter.js.es6

@@ -0,0 +1,78 @@
+((exports) => {
+  exports.$(() => {
+    const Foundation = exports.Foundation;
+    const $timeoutModal = $("#timeoutModal");
+    const timeoutInSeconds = parseInt($timeoutModal.data("session-timeout"), 10);
+    const secondsUntilTimeoutPath = $timeoutModal.data("seconds-until-timeout-path");
+    const interval = $timeoutModal.data("session-timeouter-interval");
+    let endsAt = exports.moment().add(timeoutInSeconds, "seconds");
+    const popup = new Foundation.Reveal($timeoutModal);
+    const $continueSessionButton = $("#continueSession");
+
+    // Ajax request is made at timeout_modal.html.erb
+    $continueSessionButton.on("click", () => {
+      $("#timeoutModal").foundation("close")
+      // In admin panel we have to hide all overlays
+      $(".reveal-overlay").css("display", "none");
+    })
+
+    if (!timeoutInSeconds) {
+      return;
+    }
+
+    const setTimer = (secondsUntilExpiration) => {
+      if (!secondsUntilExpiration) {
+        return;
+      }
+      endsAt = exports.moment().add(secondsUntilExpiration, "seconds")
+    }
+
+    const sessionTimeLeft = () => {
+      return $.ajax({
+        method: "GET",
+        url: secondsUntilTimeoutPath,
+        contentType: "application/json",
+        headers: {
+          "X-CSRF-Token": $("meta[name=csrf-token]").attr("content")
+        }
+      })
+    }
+
+    const exitInterval = setInterval(() => {
+      const diff = endsAt - exports.moment();
+      const diffInSeconds = Math.round(diff / 1000);
+      if (diffInSeconds > 150) {
+        return;
+      }
+
+      sessionTimeLeft().then((result) => {
+        const secondsUntilSessionExpires = result.seconds_remaining;
+        setTimer(secondsUntilSessionExpires)
+
+        if (secondsUntilSessionExpires <= 90) {
+          $timeoutModal.find("#reveal-hidden-sign-out")[0].click();
+        } else if (secondsUntilSessionExpires <= 150) {
+          popup.open();
+        }
+      });
+    }, interval);
+
+    // Devise restarts its own timer on ajax requests,
+    // so here we restart our.
+    $(document).on("ajax:complete", () => {
+      setTimer(timeoutInSeconds);
+    });
+
+    $(document).ajaxComplete((_event, _xhr, settings) => {
+      if (settings && settings.url === secondsUntilTimeoutPath) {
+        return;
+      }
+      setTimer(timeoutInSeconds);
+    });
+
+    window.addEventListener("beforeunload", () => {
+      clearInterval(exitInterval);
+      return;
+    });
+  })
+})(window)

data/app/assets/stylesheets/decidim/_variables.scss

@@ -1,3 +1,12 @@
+// Foundation Variables
+$primary-color: null;
+$secondary-color: null;
+$success-color: null;
+$warning-color: null;
+$alert-color: null;
+$-zf-size: null;
+$-zf-bp-value: null;
+
 // Variables
 
 $primary: #cb3c29 !default;