decidim-core 0.30.2 → 0.31.0.rc1

data/app/packs/src/decidim/{check_boxes_tree.js → refactor/moved/check_boxes_tree.js}

@@ -22,12 +22,18 @@ export default class CheckBoxesTree {
   /**
    * Set checkboxes as checked if included in given values
    * @public
-   * @param {Array} checkboxes - array of checkboxes to check
+   * @param {NodeList|Array|HTMLElement[]} checkboxes - array of checkboxes to check
    * @param {Array} values - values of checkboxes that should be checked
    * @returns {Void} - Returns nothing.
    */
   updateChecked(checkboxes, values) {
-    checkboxes.each((_idx, checkbox) => {
+    // Handle both NodeList/Array and jQuery-like objects
+    // eslint-disable-next-line no-undefined
+    const checkboxArray = checkboxes.length === undefined
+      ? [checkboxes]
+      : Array.from(checkboxes);
+
+    checkboxArray.forEach((checkbox) => {
       if ((checkbox.value === "" && values.length === 1) || (checkbox.value !== "" && values.includes(checkbox.value))) {
         checkbox.checked = true;
         this.checkTheCheckBoxes(checkbox);
@@ -39,21 +45,30 @@ export default class CheckBoxesTree {
   /**
    * Set the container form(s) for the component, to disable ignored filters before submitting them
    * @public
-   * @param {query} theForm - form or forms where the component will be used
+   * @param {HTMLElement} theForm - form element where the component will be used
    * @returns {Void} - Returns nothing.
    */
   setContainerForm(theForm) {
-    theForm.on("submit ajax:before", () => {
-      theForm.find(".ignore-filters input, input.ignore-filter").each((_idx, elem) => {
+    // Handle both jQuery objects and DOM elements
+    const form = theForm;
+
+    const handleBeforeSubmit = () => {
+      const ignoredInputs = form.querySelectorAll(".ignore-filters input, input.ignore-filter");
+      ignoredInputs.forEach((elem) => {
         elem.disabled = true;
       });
-    });
+    };
 
-    theForm.on("ajax:send", () => {
-      theForm.find(".ignore-filters input, input.ignore-filter").each((_idx, elem) => {
+    const handleAfterSubmit = () => {
+      const ignoredInputs = form.querySelectorAll(".ignore-filters input, input.ignore-filter");
+      ignoredInputs.forEach((elem) => {
         elem.disabled = false;
       });
-    });
+    };
+
+    form.addEventListener("submit", handleBeforeSubmit);
+    form.addEventListener("ajax:before", handleBeforeSubmit);
+    form.addEventListener("ajax:send", handleAfterSubmit);
   }
 
   /**

data/app/packs/src/decidim/{i18n.test.js → refactor/moved/i18n.test.js}

@@ -1,4 +1,4 @@
-import * as i18n from "src/decidim/i18n";
+import * as i18n from "src/decidim/refactor/moved/i18n";
 
 const config = {
   messages: {

data/app/packs/src/decidim/{icon.js → refactor/moved/icon.js}

@@ -20,6 +20,8 @@ export default function icon(iconKey, attributes = {}) {
     const newKey = key.replace(/([A-Z])/g, (ucw) => `-${ucw[0].toLowerCase()}`);
     if (typeof htmlAttributes[key] === "undefined") {
       htmlAttributes[newKey] = iconAttributes[key];
+    } else if (iconAttributes[key] === null) {
+      Reflect.deleteProperty(htmlAttributes, newKey);
     } else {
       htmlAttributes[newKey] = `${htmlAttributes[newKey]} ${iconAttributes[key]}`;
     }

data/app/packs/src/decidim/refactor/support/stimulus.js

@@ -0,0 +1,39 @@
+/*
+  Stimulus Webpack Helpers 1.0.0
+  Copyright © 2021 Basecamp, LLC
+  This is just a copy of @hotwired/stimulus-webpack-helpers functionality.
+  In order to have our own structure, we need to replace the Regex from identifierForContextKey method
+ */
+
+const identifierForContextKey = function(key) {
+  const logicalName = (key.match(/^(?:\.\/)?(.+)(?:\/controller\..+?)$/) || [])[1];
+
+  if (logicalName) {
+    return logicalName.replace(/_/g, "-").replace(/\//g, "--");
+  }
+  return null;
+}
+
+const definitionForModuleAndIdentifier = function(module, identifier) {
+  const controllerConstructor = module.default;
+  if (typeof controllerConstructor === "function") {
+    return { identifier, controllerConstructor };
+  }
+  return null;
+}
+
+const definitionForModuleWithContextAndKey = function(context, key) {
+  const identifier = identifierForContextKey(key);
+  if (identifier) {
+    return definitionForModuleAndIdentifier(context(key), identifier);
+  }
+  return null;
+}
+
+const definitionsFromContext = function(context) {
+  return context.keys().
+    map((key) => definitionForModuleWithContextAndKey(context, key)).
+    filter((value) => value);
+}
+
+export { definitionForModuleAndIdentifier, definitionForModuleWithContextAndKey, definitionsFromContext, identifierForContextKey };

data/app/packs/src/decidim/refactor/test/configuration.test.js

@@ -0,0 +1,360 @@
+/* eslint max-lines: ["error", 370] */
+/**
+ * @jest-environment jsdom
+ */
+
+import Configuration from "src/decidim/refactor/implementation/configuration";
+
+describe("Configuration", () => {
+  let config = null;
+
+  beforeEach(() => {
+    config = new Configuration();
+  });
+
+  describe("constructor", () => {
+    it("initializes with empty config object", () => {
+      expect(config.config).toEqual({});
+    });
+  });
+
+  describe("set method", () => {
+    describe("when setting individual key-value pairs", () => {
+      it("sets a string value", () => {
+        config.set("apiUrl", "https://example.com/api");
+        expect(config.config.apiUrl).toBe("https://example.com/api");
+      });
+
+      it("sets a number value", () => {
+        config.set("maxItems", 10);
+        expect(config.config.maxItems).toBe(10);
+      });
+
+      it("sets a boolean value", () => {
+        config.set("enableDebug", true);
+        expect(config.config.enableDebug).toBe(true);
+      });
+
+      it("sets an object value", () => {
+        const objectValue = { name: "Test", age: 25 };
+        config.set("userInfo", objectValue);
+        expect(config.config.userInfo).toEqual(objectValue);
+      });
+
+      it("sets an array value", () => {
+        const arrayValue = ["item1", "item2", "item3"];
+        config.set("items", arrayValue);
+        expect(config.config.items).toEqual(arrayValue);
+      });
+
+      it("sets null value explicitly", () => {
+        config.set("nullValue", null);
+        expect(config.config.nullValue).toBeNull();
+      });
+
+      it("sets undefined value when no value provided", () => {
+        config.set("undefinedValue");
+        expect(config.config.undefinedValue).toBeNull();
+      });
+
+      it("overwrites existing values", () => {
+        config.set("key", "oldValue");
+        config.set("key", "newValue");
+        expect(config.config.key).toBe("newValue");
+      });
+    });
+
+    describe("when setting multiple key-value pairs with object", () => {
+      it("merges object properties into config", () => {
+        const settings = {
+          apiUrl: "https://api.example.com",
+          timeout: 5000,
+          retries: 3
+        };
+
+        config.set(settings);
+
+        expect(config.config).toEqual(settings);
+      });
+
+      it("merges with existing config without overwriting unrelated keys", () => {
+        config.set("existingKey", "existingValue");
+
+        const newSettings = {
+          newKey1: "value1",
+          newKey2: "value2"
+        };
+
+        config.set(newSettings);
+
+        expect(config.config).toEqual({
+          existingKey: "existingValue",
+          newKey1: "value1",
+          newKey2: "value2"
+        });
+      });
+
+      it("overwrites existing keys when merging objects", () => {
+        config.set("sharedKey", "oldValue");
+        config.set("otherKey", "otherValue");
+
+        const newSettings = {
+          sharedKey: "newValue",
+          additionalKey: "additionalValue"
+        };
+
+        config.set(newSettings);
+
+        expect(config.config).toEqual({
+          sharedKey: "newValue",
+          otherKey: "otherValue",
+          additionalKey: "additionalValue"
+        });
+      });
+
+      it("handles nested objects correctly", () => {
+        const nestedSettings = {
+          database: {
+            host: "localhost",
+            port: 5432,
+            credentials: {
+              username: "admin",
+              password: "secret"
+            }
+          },
+          cache: {
+            enabled: true,
+            ttl: 3600
+          }
+        };
+
+        config.set(nestedSettings);
+
+        expect(config.config).toEqual(nestedSettings);
+      });
+
+      it("handles empty object", () => {
+        config.set("existingKey", "existingValue");
+        config.set({});
+
+        expect(config.config).toEqual({
+          existingKey: "existingValue"
+        });
+      });
+    });
+
+    describe("edge cases", () => {
+      it("handles setting with empty string key", () => {
+        config.set("", "emptyStringKey");
+        expect(config.config[""]).toBe("emptyStringKey");
+      });
+
+      it("handles setting with numeric string key", () => {
+        config.set("123", "numericStringKey");
+        expect(config.config["123"]).toBe("numericStringKey");
+      });
+
+      it("handles setting with special character keys", () => {
+        config.set("key-with-dashes", "dashValue");
+        config.set("key_with_underscores", "underscoreValue");
+        config.set("key.with.dots", "dotValue");
+
+        expect(config.config["key-with-dashes"]).toBe("dashValue");
+        expect(config.config.key_with_underscores).toBe("underscoreValue");
+        expect(config.config["key.with.dots"]).toBe("dotValue");
+      });
+    });
+  });
+
+  describe("get method", () => {
+    beforeEach(() => {
+      config.set({
+        stringValue: "test string",
+        numberValue: 42,
+        booleanValue: true,
+        nullValue: null,
+        objectValue: { nested: "value" },
+        arrayValue: [1, 2, 3]
+      });
+    });
+
+    it("retrieves existing string value", () => {
+      expect(config.get("stringValue")).toBe("test string");
+    });
+
+    it("retrieves existing number value", () => {
+      expect(config.get("numberValue")).toBe(42);
+    });
+
+    it("retrieves existing boolean value", () => {
+      expect(config.get("booleanValue")).toBe(true);
+    });
+
+    it("retrieves existing null value", () => {
+      expect(config.get("nullValue")).toBeNull();
+    });
+
+    it("retrieves existing object value", () => {
+      expect(config.get("objectValue")).toEqual({ nested: "value" });
+    });
+
+    it("retrieves existing array value", () => {
+      expect(config.get("arrayValue")).toEqual([1, 2, 3]);
+    });
+
+    it("returns undefined for nonexistent keys", () => {
+      expect(config.get("nonExistentKey")).toBeUndefined();
+    });
+
+    it("handles empty string key", () => {
+      config.set("", "emptyKeyValue");
+      expect(config.get("")).toBe("emptyKeyValue");
+    });
+
+    it("handles special character keys", () => {
+      config.set("key-with-special@chars!", "specialValue");
+      expect(config.get("key-with-special@chars!")).toBe("specialValue");
+    });
+  });
+
+  describe("integration scenarios", () => {
+    it("handles typical configuration workflow", () => {
+      // Initial setup
+      config.set({
+        apiUrl: "https://api.example.com",
+        timeout: 5000,
+        debug: false
+      });
+
+      // Verify initial state
+      expect(config.get("apiUrl")).toBe("https://api.example.com");
+      expect(config.get("timeout")).toBe(5000);
+      expect(config.get("debug")).toBe(false);
+
+      // Update individual setting
+      config.set("debug", true);
+      expect(config.get("debug")).toBe(true);
+
+      // Add new settings
+      config.set({
+        retries: 3,
+        cache: { enabled: true, ttl: 300 }
+      });
+
+      // Verify all settings
+      expect(config.get("apiUrl")).toBe("https://api.example.com");
+      expect(config.get("timeout")).toBe(5000);
+      expect(config.get("debug")).toBe(true);
+      expect(config.get("retries")).toBe(3);
+      expect(config.get("cache")).toEqual({ enabled: true, ttl: 300 });
+    });
+
+    it("maintains object references correctly", () => {
+      const originalObject = { key: "value" };
+      config.set("reference", originalObject);
+
+      const retrievedObject = config.get("reference");
+      expect(retrievedObject).toBe(originalObject);
+      expect(retrievedObject).toEqual({ key: "value" });
+
+      // Modifying the original object should affect the stored reference
+      originalObject.key = "modified";
+      expect(config.get("reference").key).toBe("modified");
+    });
+
+    it("handles complex nested configuration", () => {
+      const complexConfig = {
+        server: {
+          host: "localhost",
+          port: 3000,
+          ssl: {
+            enabled: true,
+            cert: "/path/to/cert",
+            key: "/path/to/key"
+          }
+        },
+        database: {
+          connections: {
+            primary: {
+              host: "db1.example.com",
+              port: 5432
+            },
+            replica: {
+              host: "db2.example.com",
+              port: 5432
+            }
+          }
+        },
+        features: ["auth", "cache", "logging"]
+      };
+
+      config.set(complexConfig);
+
+      expect(config.get("server")).toEqual(complexConfig.server);
+      expect(config.get("database")).toEqual(complexConfig.database);
+      expect(config.get("features")).toEqual(complexConfig.features);
+    });
+
+    it("handles multiple Configuration instances independently", () => {
+      const config1 = new Configuration();
+      const config2 = new Configuration();
+
+      config1.set("shared", "value1");
+      config2.set("shared", "value2");
+
+      expect(config1.get("shared")).toBe("value1");
+      expect(config2.get("shared")).toBe("value2");
+
+      config1.set({ additional: "config1" });
+      config2.set({ additional: "config2" });
+
+      expect(config1.get("additional")).toBe("config1");
+      expect(config2.get("additional")).toBe("config2");
+      expect(config1.get("shared")).toBe("value1");
+      expect(config2.get("shared")).toBe("value2");
+    });
+  });
+
+  describe("type validation", () => {
+    it("accepts various types as keys when using object syntax", () => {
+      // Note: Object keys are always converted to strings in JavaScript
+      const mixedKeysObject = {
+        123: "numeric key",
+        "string": "string key",
+        // This becomes "true" as a string key
+        true: "boolean key"
+      };
+
+      config.set(mixedKeysObject);
+
+      expect(config.get("123")).toBe("numeric key");
+      expect(config.get("string")).toBe("string key");
+      expect(config.get("true")).toBe("boolean key");
+    });
+
+    it("preserves value types correctly", () => {
+      const values = {
+        stringVal: "string",
+        numberVal: 123,
+        booleanVal: true,
+        nullVal: null,
+        // eslint-disable-next-line no-undefined
+        undefinedVal: undefined,
+        objectVal: {},
+        arrayVal: [],
+        functionVal: () => "test"
+      };
+
+      config.set(values);
+
+      expect(typeof config.get("stringVal")).toBe("string");
+      expect(typeof config.get("numberVal")).toBe("number");
+      expect(typeof config.get("booleanVal")).toBe("boolean");
+      expect(config.get("nullVal")).toBeNull();
+      expect(config.get("undefinedVal")).toBeUndefined();
+      expect(typeof config.get("objectVal")).toBe("object");
+      expect(Array.isArray(config.get("arrayVal"))).toBe(true);
+      expect(typeof config.get("functionVal")).toBe("function");
+    });
+  });
+});

data/app/packs/src/decidim/{external_domain_warning.test.js → refactor/test/external_domain_warning.test.js}

@@ -1,4 +1,4 @@
-import ExternalDomainLink from "src/decidim/external_domain_warning";
+import ExternalDomainLink from "src/decidim/refactor/implementation/external_domain_warning"
 
 describe("ExternalDomainLink", () => {
   const content = `

data/app/packs/src/decidim/{external_link.test.js → refactor/test/external_link.test.js}

@@ -1,6 +1,6 @@
 import $ from "jquery"; // eslint-disable-line id-length
 
-import ExternalLink from "src/decidim/external_link";
+import ExternalLink from "src/decidim/refactor/implementation/external_link"
 
 describe("ExternalLink", () => {
   const content = `

data/app/packs/src/decidim/results_listing.js

@@ -1,4 +1,4 @@
-import { pushState, registerCallback } from "src/decidim/history"
+import { pushState, registerCallback } from "src/decidim/refactor/moved/history"
 
 const initializeListingOptionsMenu = (options) => {
   $(document).on("click", `${options.containerSelector} a`, (event) => {
@@ -25,7 +25,7 @@ const initializeListingOptionsMenu = (options) => {
   });
 };
 
-$(() => {
+document.addEventListener("turbo:load", () => {
   initializeListingOptionsMenu({
     containerSelector: ".order-by",
     callbackName: "orders",

data/app/packs/src/decidim/security/selfxss_warning.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-console, no-process-env, no-undef */
 
-$(() => {
+document.addEventListener("turbo:load", () => {
   if (!console) {
     return;
   }

data/app/packs/src/decidim/session_timeouter.js

@@ -1,6 +1,6 @@
 import dayjs from "dayjs"
 
-$(() => {
+document.addEventListener("turbo:load", () => {
   let sessionTimeOutEnabled = true;
   const $timeoutModal = $("#timeoutModal");
   const timeoutInSeconds = parseInt($timeoutModal.data("session-timeout"), 10);

data/app/packs/src/decidim/sw/push-permissions.js

@@ -1,4 +1,4 @@
-window.addEventListener("DOMContentLoaded", async () => {
+window.addEventListener("turbo:load", async () => {
   const GRANTED_PERMISSION = "granted"
 
   const hideReminder = function() {

data/app/packs/src/decidim/utilities/dom.js

@@ -1,5 +1,5 @@
 import confirmAction from "src/decidim/confirm"
-import { getMessages } from "src/decidim/i18n"
+import { getMessages } from "src/decidim/refactor/moved/i18n"
 
 const { Rails } = window;
 

data/app/packs/stylesheets/decidim/_accordion.scss

@@ -1,13 +1,13 @@
-[data-component="accordion"] [id*="panel"][aria-hidden="true"] {
+[data-controller="accordion"] [id*="panel"][aria-hidden="true"] {
   display: none;
 }
 
-[data-component="accordion"]
+[data-controller="accordion"]
   [id*="comment"][class="comment-reply"][aria-hidden="true"] {
   display: none;
 }
 
-[data-component="accordion"]
+[data-controller="accordion"]
   [id*="comment"][class="comment-reply"][aria-hidden="false"] {
   display: block;
 }
@@ -41,3 +41,37 @@
     }
   }
 }
+
+.radio-accordion {
+  @apply border-b border-gray-3 mb-6;
+
+  &-title {
+    @apply font-semibold text-xl inline-block text-secondary;
+  }
+
+  &-divider {
+    @apply flex items-center items-end w-full;
+  }
+
+  &-radio {
+    @apply mr-4;
+  }
+
+  &-section.content-block__description[data-controller="accordion"] {
+    @apply pb-4 mb-4 text-md;
+
+    padding-left: 1.85rem;
+
+    ul {
+      @apply mb-0;
+    }
+
+    > [id*="panel"][aria-hidden="true"] {
+      @apply max-h-24;
+    }
+
+    button[aria-expanded="false"] {
+      @apply mt-0;
+    }
+  }
+}

data/app/packs/stylesheets/decidim/_author.scss

@@ -37,27 +37,6 @@
     }
   }
 
-  &__tooltip {
-    @apply grid grid-cols-[1fr_max-content] gap-6 odd:[&>*]:place-self-start even:[&>*]:place-self-end z-50;
-
-    /* overwrite default styles */
-    &[role="tooltip"] {
-      @apply max-w-max;
-    }
-
-    &-links {
-      @apply flex flex-col items-end justify-evenly h-full whitespace-nowrap text-sm hover:[&>*]:underline;
-    }
-  }
-
-  &__tooltip &__avatar-container {
-    @apply w-10 h-10 border-2 border-white hover:border-tertiary;
-  }
-
-  &__tooltip &__name {
-    @apply text-white text-lg font-bold hover:underline;
-  }
-
   &__coauthors {
     @apply flex flex-wrap items-center gap-2;
 

data/app/packs/stylesheets/decidim/_buttons.scss

@@ -72,6 +72,10 @@
 
     background: linear-gradient(0deg, rgba(0, 0, 0, 0.3), rgba(0, 0, 0, 0.3)),
       theme("colors.secondary");
+
+    svg {
+      @apply fill-white;
+    }
   }
 
   &__pill {

data/app/packs/stylesheets/decidim/_callout.scss

@@ -21,7 +21,7 @@
     @apply text-secondary;
   }
 
-  &[data-component="accordion"] {
+  &[data-controller="accordion"] {
     [id*="panel"][aria-hidden="true"] {
       @apply block max-h-14 overflow-hidden relative before:content-[''] before:absolute before:inset-0 before:h-full before:w-full before:bg-gradient-to-b before:from-transparent before:to-white after:content-[''] after:absolute after:inset-0 after:h-full after:w-full after:bg-gradient-to-b after:from-transparent after:to-secondary/5;
     }

data/app/packs/stylesheets/decidim/_cards.scss

@@ -144,7 +144,7 @@
     @apply mt-auto inline-flex flex-wrap gap-x-4 md:gap-0;
 
     & > div {
-      @apply inline-flex items-center gap-1 px-0 md:px-6 border-gray-3 border-0 md:border-r first:pl-0 last:pr-0 last:border-r-0 text-sm text-gray-2;
+      @apply inline-flex items-center gap-1 px-0 md:px-2 border-gray-3 border-0 md:border-r first:pl-0 last:pr-0 last:border-r-0 text-sm text-gray-2;
 
       & > svg {
         @apply w-3.5 h-3.5 fill-current text-gray;

data/app/packs/stylesheets/decidim/_content_blocks.scss

@@ -8,7 +8,7 @@
   &__description {
     @apply text-lg prose max-w-2xl;
 
-    &[data-component="accordion"] {
+    &[data-controller="accordion"] {
       [id*="panel"][aria-hidden="true"] {
         @apply block max-h-40 overflow-hidden relative first:[&_*]:mt-0 before:content-[''] before:absolute before:inset-0 before:h-full before:w-full before:bg-gradient-to-b before:from-transparent before:to-white after:content-[''] after:absolute after:inset-0 after:h-full after:w-full after:bg-gradient-to-b after:from-transparent after:to-white;
       }

data/app/packs/stylesheets/decidim/_cookies.scss

@@ -2,7 +2,7 @@
   @apply container flex flex-col md:flex-row justify-between items-start md:items-center gap-6 md:gap-24 py-6;
 
   &__container {
-    @apply fixed bottom-0 z-50 bg-white w-full shadow-[0_-4px_6px_rgba(211,211,211,0.25)];
+    @apply fixed bottom-0 z-[100] bg-white w-full shadow-[0_-4px_6px_rgba(211,211,211,0.25)];
 
     animation-name: slideInUp;
     animation-duration: 50ms;