decidim-core 0.30.1 → 0.31.0.rc1

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/_activity.scss

@@ -12,12 +12,12 @@
   &__content {
     @apply col-span-2 md:col-span-1 order-first md:order-none space-y-2;
 
-    > span:first-child {
-      span {
-        @apply text-gray-2 text-sm;
+    > div:first-child {
+      p {
+        @apply text-gray-2 text-sm inline-block;
 
         svg {
-          @apply text-gray fill-current;
+          @apply text-gray fill-current inline;
         }
       }
 

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;
@@ -163,11 +163,15 @@
   /* shared styles */
   &__highlight-metadata,
   &__grid-metadata {
-    @apply mt-auto flex items-center justify-between flex-wrap w-full text-sm text-gray-2 [&>*]:flex [&>*]:items-center [&>*]:gap-1 first:[&>*]:w-4/5;
+    @apply mt-auto flex items-center justify-between flex-wrap text-sm text-gray-2 [&>*]:flex [&>*]:items-center [&>*]:gap-1 first:[&>*]:flex-none;
 
     svg {
       @apply flex-none text-gray fill-current;
     }
+
+    [data-author] {
+      @apply flex first:[&>*]:max-w-40 -mr-8;
+    }
   }
 
   /* shared styles */

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;

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

@@ -174,10 +174,6 @@
     @apply flex-1 text-center;
   }
 
-  &__help-text-container {
-    @apply w-full h-10 relative;
-  }
-
   &__help-date {
     @apply w-1/2 relative inline-block;
   }