decidim-core 0.23.6 → 0.24.0.rc1

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

@@ -0,0 +1,117 @@
+// import Parchment from 'parchment';
+// import Quill from '../core/quill';
+// import Module from '../core/module';
+
+((exports) => {
+  const Quill = exports.Quill;
+  const History = Quill.import("modules/history");
+
+  /**
+   * Linebreak module brokes quill's default history class.
+   * So here we are moving innerHTML to undo and redo stack
+   * instead of deltas.
+   */
+  class HistoryOverride extends History {
+    constructor(quill, options) {
+      super(quill, options);
+      this.lastRecorded = 0;
+      this.ignoreChange = false;
+      this.init = false;
+      this.quill.emitter.on("editor-ready", () => {
+        this.clear();
+        const $input = $(this.quill.container).siblings('input[type="hidden"]');
+        this.stack.undo.push({content: $input.val() || "", index: this.quill.getLength() - 2 });
+        this.lastLength = this.quill.getLength();
+      })
+      /* eslint-disable max-params */
+      this.quill.on(Quill.events.EDITOR_CHANGE, (eventName, delta, oldDelta, source) => {
+        if (!delta) {
+          return;
+        }
+        if (!this.init && eventName === "selection-change") {
+          this.stack.undo[0].index = delta.index;
+        }
+        if (eventName !== Quill.events.TEXT_CHANGE || this.ignoreChange) {
+          return;
+        }
+
+        if (!this.options.userOnly || source === Quill.sources.USER) {
+          this.record(delta, oldDelta);
+        }
+      });
+      this.quill.keyboard.addBinding({ key: "Z", shortKey: true }, this.undo.bind(this));
+      this.quill.keyboard.addBinding({ key: "Z", shortKey: true, shiftKey: true }, this.redo.bind(this));
+      if (/Win/i.test(navigator.platform)) {
+        this.quill.keyboard.addBinding({ key: "Y", shortKey: true }, this.redo.bind(this));
+      }
+    }
+    /* eslint-enable max-params */
+
+    change(source, dest) {
+      if (this.stack[source].length === 0) {
+        return;
+      }
+      let obj = this.updateStacks(source, dest);
+      if (!obj.content) {
+        return;
+      }
+      if (!obj.index) {
+        obj.index = 0
+      }
+      this.lastRecorded = 0;
+      this.ignoreChange = true;
+      this.quill.setContents(this.quill.clipboard.convert(obj.content));
+      this.ignoreChange = false;
+      let index = obj.index;
+      this.quill.setSelection(index);
+    }
+
+    updateStacks(source, dest) {
+      if (source === "undo") {
+        if (this.stack.undo.length === 1) {
+          return this.stack.undo[0]
+        }
+        this.stack[dest].push(this.stack.undo.pop())
+        return this.stack.undo[this.stack.undo.length - 1]
+      }
+      let content = this.stack.redo.pop();
+      this.stack.undo.push(content)
+      return content
+    }
+
+    record(changeDelta) {
+      if (changeDelta.ops.length === 0) {
+        return
+      } else if (!this.init) {
+        this.init = true;
+      }
+      this.stack.redo = [];
+      let timestamp = Date.now();
+      // Should not return after length check, because after linebreak a keypress replaces invisible characters with
+      // visible characters.
+      // For example: <br><br></p> -> [press X] -> <br>X</p>.
+      if (Math.abs(this.lastLength === this.quill.getLength()) || this.lastRecorded + this.options.delay > timestamp) {
+        if (this.stack.undo.length > 1) {
+          this.stack.undo.pop();
+        }
+      } else {
+        this.lastLength = this.quill.getLength();
+        if (this.lastRecorded + this.options.delay <= timestamp) {
+          this.lastRecorded = timestamp;
+        }
+      }
+      this.stack.undo.push({content: this.quill.container.firstChild.innerHTML, index: this.quill.getSelection()})
+    }
+
+    transform() {
+      return;
+    }
+  }
+  History.DEFAULTS = {
+    delay: 1000,
+    maxStack: 100,
+    userOnly: true
+  };
+
+  exports.Decidim.Editor.HistoryOverride = HistoryOverride
+})(window)

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

@@ -0,0 +1,83 @@
+// = require decidim/editor/modified_enter
+// = require decidim/editor/modified_backspace_utils
+// = require decidim/editor/modified_backspace_offset_any
+// = require decidim/editor/modified_backspace_offset1
+// = require decidim/editor/history_override
+
+// It all started with these snippets of code: https://github.com/quilljs/quill/issues/252
+((exports) => {
+  const Quill = exports.Quill;
+  const Delta = Quill.import("delta");
+  const Break = Quill.import("blots/break");
+  const Embed = Quill.import("blots/embed");
+  const { HistoryOverride } = exports.Decidim.Editor
+  Quill.register({"modules/history": HistoryOverride}, true)
+  let icons = Quill.import("ui/icons");
+  icons.linebreak = "⏎";
+
+  class SmartBreak extends Break {
+    length() {
+      return 1;
+    }
+
+    value() {
+      return "\n";
+    }
+
+    insertInto(parent, ref) {
+      // Embed.prototype.insertInto.call(this, parent, ref);
+      Reflect.apply(Embed.prototype.insertInto, this, [parent, ref]);
+    }
+  }
+  Quill.register(SmartBreak);
+
+  const lineBreakButtonHandler = (quill) => {
+    let range = quill.selection.getRange()[0];
+    let currentLeaf = quill.getLeaf(range.index)[0];
+    let nextLeaf = quill.getLeaf(range.index + 1)[0];
+    const previousChar = quill.getText(range.index - 1, 1);
+
+    // Insert a second break if:
+    // At the end of the editor, OR next leaf has a different parent (<p>)
+    if (nextLeaf === null || (currentLeaf.parent !== nextLeaf.parent)) {
+      quill.insertEmbed(range.index, "break", true, "user");
+      quill.insertEmbed(range.index, "break", true, "user");
+    } else if (previousChar === "\n") {
+      const delta = new Delta().retain(range.index).insert("\n");
+      quill.updateContents(delta, Quill.sources.USER);
+    } else {
+      quill.insertEmbed(range.index, "break", true, "user");
+    }
+
+    // Now that we've inserted a line break, move the cursor forward
+    quill.setSelection(range.index + 1, Quill.sources.SILENT);
+  };
+
+  Quill.register("modules/linebreak", (quill) => {
+    const { addEnterBindings } = exports.Decidim.Editor;
+    const { backspaceBindingsRangeAny } = exports.Decidim.Editor;
+    const { backspaceBindings } = exports.Decidim.Editor;
+
+    quill.getModule("toolbar").addHandler("linebreak", () => {
+      lineBreakButtonHandler(quill);
+    });
+
+    quill.emitter.on("editor-ready", () => {
+      const length = quill.getLength();
+      const text = quill.getText(length - 2, 2);
+
+      // Remove extraneous new lines
+      if (text === "\n\n") {
+        quill.deleteText(quill.getLength() - 2, 2);
+      }
+    });
+
+    addEnterBindings(quill);
+    backspaceBindingsRangeAny(quill);
+    backspaceBindings(quill);
+
+    return;
+  });
+
+  exports.Decidim.Editor.lineBreakButtonHandler = lineBreakButtonHandler;
+})(window);

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

@@ -0,0 +1,98 @@
+((exports) => {
+  const Quill = exports.Quill;
+  const Delta = Quill.import("delta");
+  const { attributeDiff } = exports.Decidim.Editor;
+
+  const previousChar = (quill, range) => {
+    return quill.getText(range.index - 1, 1);
+  }
+
+  const beforePreviousChar = (quill, range) => {
+    return quill.getText(range.index - 2, 1);
+  }
+
+  const nextChar = (quill, range) => {
+    return quill.getText(range.index, 1);
+  }
+
+  const handleListSelection = (quill, range) => {
+    const lastCharacterOfPreviousLine = quill.getText(range.index - 3, 1);
+    if (nextChar(quill, range) === "\n" || lastCharacterOfPreviousLine !== "\n") {
+      quill.setSelection(range.index - 1, Quill.sources.SILENT);
+    } else {
+      quill.setSelection(range.index - 3, Quill.sources.SILENT);
+    }
+  }
+
+  const moveSelectionToPreviousLine = (quill, range) => {
+    const lastCharacterOfPreviousLine = quill.getText(range.index - 3, 1);
+    if (nextChar(quill, range) === "\n" || lastCharacterOfPreviousLine !== "\n") {
+      quill.setSelection(range.index - 1, Quill.sources.SILENT);
+    } else {
+      quill.setSelection(range.index - 3, Quill.sources.SILENT);
+    }
+  }
+
+  const backspaceBindings = (quill) => {
+    quill.keyboard.addBinding({ key: 8, offset: 1, collapsed: true }, (range, context) => {
+      let length = 1
+      if (/[\uD800-\uDBFF][\uDC00-\uDFFF]$/.test(context.prefix)) {
+        length = 2;
+      }
+
+      if (range.index === 0 || quill.getLength() <= 1) {
+        return;
+      }
+      let formats = {};
+      const [line] = quill.getLine(range.index);
+      let delta = new Delta().retain(range.index - length).delete(length);
+      if (context.offset === 1 && previousChar(quill, range) === "\n") {
+        const [prev] = quill.getLine(range.index - 2);
+        if (prev && prev.statics.blotName === "list-item") {
+          formats = handleListSelection(quill, range);
+          if (prev !== null && prev.length() > 1) {
+            let curFormats = line.formats();
+            let prevFormats = quill.getFormat(range.index - 2, 1);
+            formats = attributeDiff(curFormats, prevFormats) || {};
+            length += 1;
+          }
+          delta = new Delta().retain(range.index - 2).delete(2);
+          moveSelectionToPreviousLine(quill, range);
+        } else {
+          delta = new Delta().retain(range.index - 1).delete(1);
+          if (range.index < 2) {
+            delta = new Delta().delete(1).retain(range.index + line.length() - 1);
+          } else if (previousChar(quill, range) === "\n" && beforePreviousChar(quill, range) === "\n") {
+            delta = new Delta().retain(range.index - 2).delete(2);
+          }
+        }
+      } else {
+        const [prev] = quill.getLine(range.index - 1);
+        if (prev) {
+          const isPrevLineEmpty =
+            prev.statics.blotName === "block" && prev.length() <= 1;
+          if (!isPrevLineEmpty) {
+            const curFormats = line.formats();
+            const prevFormats = quill.getFormat(range.index - 1, 1);
+            formats = attributeDiff(curFormats, prevFormats) || {};
+            if (Object.keys(formats).length > 0) {
+              // line.length() - 1 targets \n in line, another -1 for newline being deleted
+              const formatDelta = new Delta().retain(range.index + line.length() - 2).retain(1, formats);
+              delta = delta.compose(formatDelta);
+            }
+          }
+        }
+      }
+      quill.updateContents(delta, Quill.sources.USER);
+      if (Object.keys(formats).length > 0) {
+        quill.formatLine(range.index - length, length, formats, Quill.sources.USER);
+      }
+      quill.focus();
+    });
+
+    // Put this backspace binding to second
+    quill.keyboard.bindings[8].splice(1, 0, quill.keyboard.bindings[8].pop());
+  }
+
+  exports.Decidim.Editor.backspaceBindings = backspaceBindings;
+})(window)

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

@@ -0,0 +1,48 @@
+((exports) => {
+  const Quill = exports.Quill;
+  const { attributeDiff } = exports.Decidim.Editor
+
+  const backspaceBindingsRangeAny = (quill) => {
+    quill.keyboard.addBinding({ key: 8, altKey: null, ctrlKey: null, metaKey: null, shiftKey: null, collapsed: true }, (range, context) => {
+      let length = 1;
+      if (range.index === 0 || quill.getLength() <= 1) {
+        return;
+      }
+      let [line] = quill.getLine(range.index);
+      let formats = {};
+      if (context.offset === 0) {
+        let [prev] = quill.getLine(range.index - 1);
+        if (prev !== null && prev.length() > 1) {
+          let curFormats = line.formats();
+          let prevFormats = quill.getFormat(range.index - 1, 1);
+          formats = attributeDiff(curFormats, prevFormats) || {};
+          const previousLineLength = quill.getLine(range.index - 1)[1];
+          const previousChar = quill.getText(range.index - 1, 1)
+          const beforePreviousChar = quill.getText(range.index - 2, 1);
+          if (previousLineLength && previousLineLength === 1 && beforePreviousChar === "\n") {
+            if (prevFormats && prevFormats.list) {
+              quill.setSelection(range.index - 2, Quill.sources.SILENT);
+            } else if (previousChar === "\n" && beforePreviousChar === "\n") {
+              length += 1;
+            }
+          }
+        }
+      }
+
+      if (/[\uD800-\uDBFF][\uDC00-\uDFFF]$/.test(context.prefix)) {
+        length += 1;
+      }
+      quill.deleteText(range.index - length, length, Quill.sources.USER);
+
+      if (Object.keys(formats).length > 0) {
+        quill.formatLine(range.index - length, length, formats, Quill.sources.USER);
+      }
+      quill.focus();
+    })
+
+    // Put this backspace binding to second (after backspce_offset1 it's going to be third)
+    quill.keyboard.bindings[8].splice(1, 0, quill.keyboard.bindings[8].pop());
+  }
+
+  exports.Decidim.Editor.backspaceBindingsRangeAny = backspaceBindingsRangeAny;
+})(window)

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/editor.js.es6

@@ -1,15 +1,16 @@
 // = require quill.min
+// = require decidim/editor/linebreak_module
 // = require_self
 
 ((exports) => {
-  const quillFormats = ["bold", "italic", "link", "underline", "header", "list", "video", "image", "alt"];
+  const quillFormats = ["bold", "italic", "link", "underline", "header", "list", "video", "image", "alt", "break"];
 
   const createQuillEditor = (container) => {
     const toolbar = $(container).data("toolbar");
     const disabled = $(container).data("disabled");
 
     let quillToolbar = [
-      ["bold", "italic", "underline"],
+      ["bold", "italic", "underline", "linebreak"],
       [{ list: "ordered" }, { list: "bullet" }],
       ["link", "clean"]
     ];
@@ -32,7 +33,13 @@
 
     const quill = new Quill(container, {
       modules: {
-        toolbar: quillToolbar
+        linebreak: {},
+        toolbar: {
+          container: quillToolbar,
+          handlers: {
+            "linebreak": exports.Decidim.Editor.lineBreakButtonHandler
+          }
+        }
       },
       formats: quillFormats,
       theme: "snow"
@@ -52,12 +59,16 @@
       });
       container.dispatchEvent(event);
 
-      if (text === "\n") {
+      if (text === "\n" || text === "\n\n") {
         $input.val("");
       } else {
         $input.val(quill.root.innerHTML);
       }
     });
+    // After editor is ready, linebreak_module deletes two extraneous new lines
+    quill.emitter.emit("editor-ready");
+
+    return quill;
   };
 
   const quillEditor = () => {

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/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);