feat: Modular feature flag system using Service Provider Interface (#22361)

Refactored feature flags to use Service Provider Interface (SPI) pattern,
allowing each module to define its own feature flags that are dynamically
loaded at runtime. This eliminates the need to hardcode all feature flags
in the FeatureFlags class.

Changes:
- Added FeatureFlagProvider interface for modules to implement
- Split feature flags into domain-specific providers:
  - CoreFeatureFlagProvider: Core Flow framework features
  - CopilotFeatureFlagProvider: Copilot-related features (placeholder)
  - HillaFeatureFlagProvider: Hilla-related features
  - FlowComponentsFeatureFlagProvider: Flow Components features
  - TestFeatureFlagProvider: Test-only features (in test sources)
- Updated FeatureFlags to load features dynamically via ServiceLoader
- Removed static feature flag definitions from FeatureFlags
- Maintained backward compatibility with public static references for commonly used flags
- Updated debug window to no longer filter EXAMPLE feature (now only in tests)
- Fixed Maven plugin's CombinedClassLoader to properly combine resources from all
  classloaders, allowing ServiceLoader to find all service provider files

The CombinedClassLoader fix ensures that the build-dev-bundle plugin can properly
load feature flag providers by combining META-INF/services resources from all
classloaders instead of returning resources from only the first classloader.

This design provides better modularity and extensibility, allowing new modules
to easily add their own feature flags without modifying core classes.

Fixes #13356

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Artur-

flow-plugins/flow-dev-bundle-plugin/src/main/java/com/vaadin/flow/plugin/maven/Reflector.java

@@ -23,6 +23,7 @@
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.List;
@@ -401,15 +402,33 @@ public URL getResource(String name) {
 
         @Override
         public Enumeration<URL> getResources(String name) throws IOException {
+            List<URL> allResources = new ArrayList<>();
+
+            // Collect resources from all classloaders
             Enumeration<URL> resources = super.getResources(name);
-            if (!resources.hasMoreElements() && delegate != null) {
+            while (resources.hasMoreElements()) {
+                allResources.add(resources.nextElement());
+            }
+
+            if (delegate != null) {
                 resources = delegate.getResources(name);
+                while (resources.hasMoreElements()) {
+                    URL url = resources.nextElement();
+                    if (!allResources.contains(url)) {
+                        allResources.add(url);
+                    }
+                }
             }
-            if (!resources.hasMoreElements()) {
-                resources = ClassLoader.getPlatformClassLoader()
-                        .getResources(name);
+
+            resources = ClassLoader.getPlatformClassLoader().getResources(name);
+            while (resources.hasMoreElements()) {
+                URL url = resources.nextElement();
+                if (!allResources.contains(url)) {
+                    allResources.add(url);
+                }
             }
-            return resources;
+
+            return Collections.enumeration(allResources);
         }
     }
 

flow-plugins/flow-maven-plugin/src/main/java/com/vaadin/flow/plugin/maven/Reflector.java

@@ -28,6 +28,7 @@
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.List;
@@ -473,15 +474,33 @@ public URL getResource(String name) {
 
         @Override
         public Enumeration<URL> getResources(String name) throws IOException {
+            List<URL> allResources = new ArrayList<>();
+
+            // Collect resources from all classloaders
             Enumeration<URL> resources = super.getResources(name);
-            if (!resources.hasMoreElements() && delegate != null) {
+            while (resources.hasMoreElements()) {
+                allResources.add(resources.nextElement());
+            }
+
+            if (delegate != null) {
                 resources = delegate.getResources(name);
+                while (resources.hasMoreElements()) {
+                    URL url = resources.nextElement();
+                    if (!allResources.contains(url)) {
+                        allResources.add(url);
+                    }
+                }
             }
-            if (!resources.hasMoreElements()) {
-                resources = ClassLoader.getPlatformClassLoader()
-                        .getResources(name);
+
+            resources = ClassLoader.getPlatformClassLoader().getResources(name);
+            while (resources.hasMoreElements()) {
+                URL url = resources.nextElement();
+                if (!allResources.contains(url)) {
+                    allResources.add(url);
+                }
             }
-            return resources;
+
+            return Collections.enumeration(allResources);
         }
 
         /**

flow-plugins/flow-plugin-base/src/test/java/com/vaadin/flow/plugin/base/BuildFrontendUtilTest.java

@@ -708,9 +708,9 @@ public void runNodeUpdater_generateFeatureFlagsJsFile() throws Exception {
                 .readString(generatedFeatureFlagsFile.toPath())
                 .replace("\r\n", "\n");
 
-        Assert.assertTrue("Example feature should not be set at build time",
+        Assert.assertFalse("Example feature should not be set at build time",
                 featureFlagsJs.contains(
-                        "window.Vaadin.featureFlags.exampleFeatureFlag = false;\n"));
+                        "window.Vaadin.featureFlags.exampleFeatureFlag"));
     }
 
     private void fillAdapter() throws URISyntaxException {

flow-server/src/main/java/com/vaadin/experimental/CoreFeatureFlagProvider.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.experimental;
+
+import java.util.List;
+
+/**
+ * Provides core Flow framework feature flags.
+ *
+ * @since 25.0
+ */
+public class CoreFeatureFlagProvider implements FeatureFlagProvider {
+
+    public static final Feature COLLABORATION_ENGINE_BACKEND = new Feature(
+            "Collaboration Kit backend for clustering support",
+            "collaborationEngineBackend",
+            "https://github.com/vaadin/platform/issues/1988", true, null);
+
+    public static final Feature FLOW_FULLSTACK_SIGNALS = new Feature(
+            "Flow Full-stack Signals", "flowFullstackSignals",
+            "https://github.com/vaadin/platform/issues/7373", true, null);
+
+    public static final Feature ACCESSIBLE_DISABLED_BUTTONS = new Feature(
+            "Accessible disabled buttons", "accessibleDisabledButtons",
+            "https://github.com/vaadin/web-components/issues/4585", true, null);
+
+    public static final Feature COMPONENT_STYLE_INJECTION = new Feature(
+            "Enable theme component style injection", "themeComponentStyles",
+            "https://github.com/vaadin/flow/issues/21608", true, null);
+
+    public static final Feature COPILOT_EXPERIMENTAL = new Feature(
+            "Copilot experimental features", "copilotExperimentalFeatures",
+            "https://vaadin.com/docs/latest/tools/copilot", false, null);
+
+    @Override
+    public List<Feature> getFeatures() {
+        return List.of(COLLABORATION_ENGINE_BACKEND, FLOW_FULLSTACK_SIGNALS,
+                ACCESSIBLE_DISABLED_BUTTONS, COMPONENT_STYLE_INJECTION,
+                COPILOT_EXPERIMENTAL);
+    }
+}

flow-server/src/main/java/com/vaadin/experimental/FeatureFlagProvider.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.experimental;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * Service provider interface for modules to declare their feature flags.
+ * <p>
+ * Implementations should be registered via the Java Service Provider Interface
+ * mechanism by creating a file named
+ * {@code META-INF/services/com.vaadin.experimental.FeatureFlagProvider}
+ * containing the fully qualified class name of the implementation.
+ * <p>
+ * This allows each module to define its own feature flags that will only be
+ * loaded when the module is on the classpath.
+ *
+ * @since 25.0
+ */
+public interface FeatureFlagProvider extends Serializable {
+
+    /**
+     * Returns the list of features provided by this module.
+     * <p>
+     * The returned list should be immutable and not change during the lifetime
+     * of the application.
+     *
+     * @return list of features, never null
+     */
+    List<Feature> getFeatures();
+}

flow-server/src/main/java/com/vaadin/experimental/FeatureFlags.java

@@ -24,9 +24,12 @@
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Properties;
+import java.util.ServiceLoader;
 import java.util.function.Function;
 
 import org.apache.commons.io.FileUtils;
@@ -51,51 +54,17 @@ public class FeatureFlags implements Serializable {
 
     public static final String SYSTEM_PROPERTY_PREFIX_EXPERIMENTAL = "vaadin.experimental.";
 
-    public static final Feature EXAMPLE = new Feature(
-            "Example feature. Internally used for testing purposes. Does not have any effect on production applications.",
-            "exampleFeatureFlag", "https://github.com/vaadin/flow/pull/12004",
-            false,
-            "com.vaadin.flow.server.frontend.NodeTestComponents$ExampleExperimentalComponent");
-    public static final Feature COLLABORATION_ENGINE_BACKEND = new Feature(
-            "Collaboration Kit backend for clustering support",
-            "collaborationEngineBackend",
-            "https://github.com/vaadin/platform/issues/1988", true, null);
-
-    public static final Feature COPILOT_EXPERIMENTAL = new Feature(
-            "Copilot experimental features", "copilotExperimentalFeatures",
-            "https://vaadin.com/docs/latest/tools/copilot", false, null);
-
-    public static final Feature HILLA_FULLSTACK_SIGNALS = new Feature(
-            "Hilla Full-stack Signals", "fullstackSignals",
-            "https://github.com/vaadin/hilla/discussions/1902", true, null);
-
-    public static final Feature FLOW_FULLSTACK_SIGNALS = new Feature(
-            "Flow Full-stack Signals", "flowFullstackSignals",
-            "https://github.com/vaadin/platform/issues/7373", true, null);
-
-    public static final Feature MASTER_DETAIL_LAYOUT_COMPONENT = new Feature(
-            "Master Detail Layout component", "masterDetailLayoutComponent",
-            "https://github.com/vaadin/platform/issues/7173", true,
-            "com.vaadin.flow.component.masterdetaillayout.MasterDetailLayout");
-
-    public static final Feature ACCESSIBLE_DISABLED_BUTTONS = new Feature(
-            "Accessible disabled buttons", "accessibleDisabledButtons",
-            "https://github.com/vaadin/web-components/issues/4585", true, null);
-
-    public static final Feature LAYOUT_COMPONENT_IMPROVEMENTS = new Feature(
-            "HorizontalLayout and VerticalLayout improvements",
-            "layoutComponentImprovements",
-            "https://github.com/vaadin/flow-components/issues/6998", true,
-            null);
-
-    public static final Feature DEFAULT_AUTO_RESPONSIVE_FORM_LAYOUT = new Feature(
-            "Form Layout auto-responsive mode enabled by default",
-            "defaultAutoResponsiveFormLayout",
-            "https://github.com/vaadin/platform/issues/7172", true, null);
-
-    public static final Feature COMPONENT_STYLE_INJECTION = new Feature(
-            "Enable theme component style injection", "themeComponentStyles",
-            "https://github.com/vaadin/flow/issues/21608", true, null);
+    // Feature constants pointing to provider definitions for backward
+    // compatibility
+    public static final Feature COLLABORATION_ENGINE_BACKEND = CoreFeatureFlagProvider.COLLABORATION_ENGINE_BACKEND;
+    public static final Feature FLOW_FULLSTACK_SIGNALS = CoreFeatureFlagProvider.FLOW_FULLSTACK_SIGNALS;
+    public static final Feature ACCESSIBLE_DISABLED_BUTTONS = CoreFeatureFlagProvider.ACCESSIBLE_DISABLED_BUTTONS;
+    public static final Feature COMPONENT_STYLE_INJECTION = CoreFeatureFlagProvider.COMPONENT_STYLE_INJECTION;
+    public static final Feature COPILOT_EXPERIMENTAL = CoreFeatureFlagProvider.COPILOT_EXPERIMENTAL;
+    public static final Feature HILLA_FULLSTACK_SIGNALS = HillaFeatureFlagProvider.HILLA_FULLSTACK_SIGNALS;
+    public static final Feature MASTER_DETAIL_LAYOUT_COMPONENT = FlowComponentsFeatureFlagProvider.MASTER_DETAIL_LAYOUT_COMPONENT;
+    public static final Feature LAYOUT_COMPONENT_IMPROVEMENTS = FlowComponentsFeatureFlagProvider.LAYOUT_COMPONENT_IMPROVEMENTS;
+    public static final Feature DEFAULT_AUTO_RESPONSIVE_FORM_LAYOUT = FlowComponentsFeatureFlagProvider.DEFAULT_AUTO_RESPONSIVE_FORM_LAYOUT;
 
     private List<Feature> features = new ArrayList<>();
 
@@ -117,16 +86,7 @@ public class FeatureFlags implements Serializable {
      */
     public FeatureFlags(Lookup lookup) {
         this.lookup = lookup;
-        features.add(new Feature(EXAMPLE));
-        features.add(new Feature(COLLABORATION_ENGINE_BACKEND));
-        features.add(new Feature(HILLA_FULLSTACK_SIGNALS));
-        features.add(new Feature(FLOW_FULLSTACK_SIGNALS));
-        features.add(new Feature(COPILOT_EXPERIMENTAL));
-        features.add(new Feature(MASTER_DETAIL_LAYOUT_COMPONENT));
-        features.add(new Feature(ACCESSIBLE_DISABLED_BUTTONS));
-        features.add(new Feature(LAYOUT_COMPONENT_IMPROVEMENTS));
-        features.add(new Feature(DEFAULT_AUTO_RESPONSIVE_FORM_LAYOUT));
-        features.add(new Feature(COMPONENT_STYLE_INJECTION));
+        loadFeaturesFromProviders();
         loadProperties();
     }
 
@@ -425,4 +385,52 @@ private void checkForUnsupportedFeatureFlags(Properties props,
             }
         }
     }
+
+    /**
+     * Loads feature flags from all available FeatureFlagProvider
+     * implementations using the ServiceLoader mechanism.
+     */
+    private void loadFeaturesFromProviders() {
+        try {
+            ServiceLoader<FeatureFlagProvider> loader = ServiceLoader.load(
+                    FeatureFlagProvider.class,
+                    this.getClass().getClassLoader());
+
+            Map<String, String> featureIdToProvider = new HashMap<>();
+
+            for (FeatureFlagProvider provider : loader) {
+                List<Feature> providerFeatures = provider.getFeatures();
+                if (providerFeatures != null) {
+                    String providerName = provider.getClass().getName();
+                    for (Feature feature : providerFeatures) {
+                        // Check for feature ID conflicts
+                        String existingProvider = featureIdToProvider
+                                .get(feature.getId());
+                        if (existingProvider != null) {
+                            getLogger().warn(
+                                    "Feature flag conflict: Feature ID '{}' is defined by both '{}' and '{}'. "
+                                            + "Using the first definition from '{}'. "
+                                            + "Each feature flag should have a unique ID across all providers.",
+                                    feature.getId(), existingProvider,
+                                    providerName, existingProvider);
+                            // Skip this duplicate feature
+                            continue;
+                        }
+
+                        featureIdToProvider.put(feature.getId(), providerName);
+                        // Create new Feature instances to ensure proper
+                        // isolation
+                        features.add(new Feature(feature));
+                    }
+                }
+            }
+
+            if (!features.isEmpty()) {
+                getLogger().debug("Loaded {} feature flags from providers",
+                        features.size());
+            }
+        } catch (Exception e) {
+            getLogger().warn("Failed to load feature flags from providers", e);
+        }
+    }
 }