allow nodes to be detached from their parent container

Author: Kaleidox

src/main/java/org/comroid/interaction/adapter/jda/DiscordCommandRegistrator.java

@@ -22,6 +22,7 @@
 import org.comroid.api.func.exc.ThrowingFunction;
 import org.comroid.api.tree.Initializable;
 import org.comroid.interaction.InteractionCore;
+import org.comroid.interaction.annotation.ContextDefinition;
 import org.comroid.interaction.component.NameCapitalizer;
 import org.comroid.interaction.node.GroupNode;
 import org.comroid.interaction.node.MethodNode;
@@ -31,9 +32,11 @@
 import org.jspecify.annotations.NonNull;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Predicate;
 import java.util.logging.Level;
 import java.util.stream.Stream;
 
@@ -63,6 +66,22 @@ public void initialize() {
                             base.getInteraction().getDescription() != null ? base.getInteraction().getDescription() : InteractionCore.NO_DESCRIPTION);
 
                     for (var child : group.getChildren()) {
+                        var contexts = child.getDefinition(JdaAdapter.KEY_CONTEXT).map(ContextDefinition::expr).flatMap(Arrays::stream).toList();
+
+                        if (contexts.stream().anyMatch(Predicate.not(JdaAdapter.CONTEXT_COMMAND::equals))) {
+                            CommandData contextual;
+
+                            if (contexts.contains(CONTEXT_MESSAGE)) contextual = Commands.message(cap.getCapitalization(NameCapitalizer.ComponentType.TITLE)
+                                    .convert(child.getInteraction().value()));
+                            else if (contexts.contains(CONTEXT_USER)) contextual = Commands.user(cap.getCapitalization(NameCapitalizer.ComponentType.TITLE)
+                                    .convert(child.getInteraction().value()));
+                            else throw new IllegalStateException("Unknown contexts: " + String.join(", ", contexts));
+
+                            initCommandData(child, contextual);
+                            all.add(contextual);
+                            continue;
+                        }
+
                         var subcommand = createSubcommand(child);
                         ((SlashCommandData) data).addSubcommands(subcommand);
                     }

src/main/java/org/comroid/interaction/annotation/Interaction.java

@@ -33,6 +33,9 @@
     /// context definitions to emit
     ContextDefinition[] definitions() default { };
 
+    /// whether to detach this interaction from its parent container
+    boolean detached() default false;
+
     enum PrivacyLevel {
         /// response is sent publicly
         PUBLIC,
@@ -43,19 +46,28 @@ enum PrivacyLevel {
     }
 
     @SuppressWarnings("ClassExplicitlyAnnotation")
-    record Resolved(String value, String description, boolean async, PrivacyLevel privacy, ContextFilter[] filter, ContextDefinition[] definitions)
-            implements Interaction, Described {
+    record Resolved(
+            String value, String description, boolean async, PrivacyLevel privacy, ContextFilter[] filter, ContextDefinition[] definitions, boolean detached
+    ) implements Interaction, Described {
         public static Resolved of(Element element, @Nullable Element parent) {
+            var detached = element.interaction.detached();
             return new Resolved(RegistryHelper.findName(element).orElseThrow(),
                     RegistryHelper.findDescription(element.annotated).orElse(null),
                     element.interaction.async() || parent != null && parent.interaction.async(),
                     element.interaction.privacy(),
                     Stream.concat(Arrays.stream(element.interaction.filter()),
-                                    Stream.ofNullable(parent).filter(Objects::nonNull).map(Element::interaction).flatMap(it -> Arrays.stream(it.filter())))
-                            .toArray(ContextFilter[]::new),
+                            Stream.ofNullable(parent)
+                                    .filter($ -> !detached)
+                                    .filter(Objects::nonNull)
+                                    .map(Element::interaction)
+                                    .flatMap(it -> Arrays.stream(it.filter()))).toArray(ContextFilter[]::new),
                     Stream.concat(Arrays.stream(element.interaction.definitions()),
-                                    Stream.ofNullable(parent).filter(Objects::nonNull).map(Element::interaction).flatMap(it -> Arrays.stream(it.definitions())))
-                            .toArray(ContextDefinition[]::new));
+                            Stream.ofNullable(parent)
+                                    .filter($ -> !detached)
+                                    .filter(Objects::nonNull)
+                                    .map(Element::interaction)
+                                    .flatMap(it -> Arrays.stream(it.definitions()))).toArray(ContextDefinition[]::new),
+                    detached);
         }
 
         @Override

src/main/java/org/comroid/interaction/registry/RegistryHelper.java

@@ -24,10 +24,12 @@
 import java.util.Set;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Stream;
 
 @Internal
 public final class RegistryHelper {
     public static Collection<InteractionNode> compileFromClass(@NonNull RegistrySource source, @NonNull Class<?> type) {
+        var detached = new ArrayList<InteractionNode>();
         var children = new ArrayList<InteractionNode>();
 
         for (var subtype : type.getClasses()) {
@@ -46,10 +48,11 @@ public static Collection<InteractionNode> compileFromClass(@NonNull RegistrySour
             var callable = constructMethod(source, method, base == null ? null : base.toInteractionElement()).orElse(null);
             if (callable == null) continue;
 
-            children.add(callable);
+            if (callable.getInteraction().detached()) detached.add(callable);
+            else children.add(callable);
         }
 
-        return base == null ? children : List.of(base);
+        return Stream.concat(detached.stream(), Stream.ofNullable(base)).toList();
     }
 
     public static Optional<GroupNode> constructGroup(@NonNull RegistrySource source, @NonNull Class<?> type, List<? extends InteractionNode> children) {