com.wallstop-studios.dxmessaging 3.1.0 → 3.2.1

package/Editor/CustomEditors/MessageAwareComponentInspectorView.cs

@@ -0,0 +1,279 @@
+namespace DxMessaging.Editor.CustomEditors
+{
+#if UNITY_EDITOR
+    using System;
+    using DxMessaging.Editor;
+    using DxMessaging.Editor.Analyzers;
+    using UnityEngine;
+    using UnityEngine.UIElements;
+
+    internal static class MessageAwareComponentInspectorView
+    {
+        internal const string RootName = "dxmessaging-inspector-warning";
+        internal const string TitleLabelName = "dxmessaging-inspector-warning-title";
+        internal const string BodyLabelName = "dxmessaging-inspector-warning-body";
+        internal const string MethodListName = "dxmessaging-inspector-warning-methods";
+        internal const string StaleCacheNoteName = "dxmessaging-inspector-warning-stale-note";
+        internal const string OpenScriptButtonName = "dxmessaging-inspector-warning-open-script";
+        internal const string IgnoreTypeButtonName = "dxmessaging-inspector-warning-ignore-type";
+        internal const string StopIgnoringButtonName =
+            "dxmessaging-inspector-warning-stop-ignoring";
+
+        internal const string RootClassName = "dxmessaging-inspector-warning";
+        internal const string StateNoneClassName = "dxmessaging-inspector-warning--none";
+        internal const string StateInfoClassName = "dxmessaging-inspector-warning--info";
+        internal const string StateWarningClassName = "dxmessaging-inspector-warning--warning";
+        internal const string TitleClassName = "dxmessaging-inspector-warning__title";
+        internal const string BodyClassName = "dxmessaging-inspector-warning__body";
+        internal const string MethodListClassName = "dxmessaging-inspector-warning__methods";
+        internal const string MethodClassName = "dxmessaging-inspector-warning__method";
+        internal const string StaleCacheNoteClassName = "dxmessaging-inspector-warning__stale-note";
+        internal const string ActionRowClassName = "dxmessaging-inspector-warning__actions";
+        internal const string ActionButtonClassName = "dxmessaging-inspector-warning__button";
+
+        private static readonly Color InfoColor = DxMessagingEditorPalette.Untargeted;
+        private static readonly Color WarningColor = DxMessagingEditorPalette.Amber;
+
+        internal static VisualElement Create(
+            MessageAwareComponentInspectorState state,
+            MessageAwareComponentInspectorViewActions actions
+        )
+        {
+            VisualElement root = CreateRoot(state);
+            switch (state.Kind)
+            {
+                case MessageAwareComponentInspectorStateKind.None:
+                    return root;
+                case MessageAwareComponentInspectorStateKind.HarvesterUnavailable:
+                    PopulateInfo(
+                        root,
+                        "Inspector overlay unavailable",
+                        "DxMessaging inspector overlay is disabled on this Unity version. Check the console for DXMSG006/007/009 warnings instead.",
+                        InfoColor
+                    );
+                    return root;
+                case MessageAwareComponentInspectorStateKind.IgnoredType:
+                    PopulateInfo(
+                        root,
+                        "Base-call check ignored",
+                        $"{state.FullName} is excluded from the DxMessaging base-call check.",
+                        InfoColor
+                    );
+                    AddActionRow(
+                        root,
+                        CreateActionButton(
+                            StopIgnoringButtonName,
+                            "Stop ignoring",
+                            actions.OnStopIgnoring,
+                            state
+                        )
+                    );
+                    return root;
+                case MessageAwareComponentInspectorStateKind.MissingBaseCallWarning:
+                    PopulateWarning(root, state, actions);
+                    return root;
+                default:
+                    return root;
+            }
+        }
+
+        private static VisualElement CreateRoot(MessageAwareComponentInspectorState state)
+        {
+            VisualElement root = new() { name = RootName };
+            DxMessagingEditorTheme.Apply(root);
+            root.AddToClassList(RootClassName);
+            root.style.marginTop = 6;
+            root.style.marginBottom = 6;
+
+            switch (state.Kind)
+            {
+                case MessageAwareComponentInspectorStateKind.None:
+                    root.AddToClassList(StateNoneClassName);
+                    break;
+                case MessageAwareComponentInspectorStateKind.MissingBaseCallWarning:
+                    root.AddToClassList(StateWarningClassName);
+                    break;
+                default:
+                    root.AddToClassList(StateInfoClassName);
+                    break;
+            }
+
+            return root;
+        }
+
+        private static void PopulateInfo(
+            VisualElement root,
+            string titleText,
+            string bodyText,
+            Color borderColor
+        )
+        {
+            ConfigurePanel(root, borderColor);
+            root.AddToClassList(DxMessagingEditorTheme.AdmonitionClassName);
+            root.AddToClassList(DxMessagingEditorTheme.NoteClassName);
+            root.Add(CreateLabel(TitleLabelName, TitleClassName, titleText, bold: true));
+            root.Add(CreateLabel(BodyLabelName, BodyClassName, bodyText, bold: false));
+        }
+
+        private static void PopulateWarning(
+            VisualElement root,
+            MessageAwareComponentInspectorState state,
+            MessageAwareComponentInspectorViewActions actions
+        )
+        {
+            ConfigurePanel(root, WarningColor);
+            root.AddToClassList(DxMessagingEditorTheme.AdmonitionClassName);
+            root.AddToClassList(DxMessagingEditorTheme.WarningClassName);
+            root.Add(
+                CreateLabel(
+                    TitleLabelName,
+                    TitleClassName,
+                    "Missing MessageAwareComponent base calls",
+                    bold: true
+                )
+            );
+            root.Add(
+                CreateLabel(
+                    BodyLabelName,
+                    BodyClassName,
+                    $"{state.FullName} has lifecycle methods that do not chain to MessageAwareComponent. DxMessaging will not function on this component. See docs/reference/analyzers.md.",
+                    bold: false
+                )
+            );
+            root.Add(CreateMethodList(state));
+
+            if (!state.IsFreshThisSession)
+            {
+                root.Add(
+                    CreateLabel(
+                        StaleCacheNoteName,
+                        StaleCacheNoteClassName,
+                        "Report is cached from previous session; refreshing...",
+                        bold: false
+                    )
+                );
+            }
+
+            AddActionRow(
+                root,
+                CreateActionButton(
+                    OpenScriptButtonName,
+                    "Open Script",
+                    actions.OnOpenScript,
+                    state
+                ),
+                CreateActionButton(
+                    IgnoreTypeButtonName,
+                    "Ignore this type",
+                    actions.OnIgnoreType,
+                    state
+                )
+            );
+        }
+
+        private static void ConfigurePanel(VisualElement root, Color borderColor)
+        {
+            DxMessagingEditorTheme.ApplyCompleteBorder(root, borderColor);
+            root.style.paddingTop = 8;
+            root.style.paddingRight = 10;
+            root.style.paddingBottom = 8;
+            root.style.paddingLeft = 10;
+        }
+
+        private static Label CreateLabel(string name, string className, string text, bool bold)
+        {
+            Label label = new(text) { name = name };
+            label.AddToClassList(className);
+            label.style.whiteSpace = WhiteSpace.Normal;
+            if (bold)
+            {
+                label.style.unityFontStyleAndWeight = FontStyle.Bold;
+            }
+            return label;
+        }
+
+        private static VisualElement CreateMethodList(MessageAwareComponentInspectorState state)
+        {
+            VisualElement methodList = new() { name = MethodListName };
+            methodList.AddToClassList(MethodListClassName);
+            methodList.style.marginTop = 5;
+
+            if (state.Entry == null || state.Entry.missingBaseFor == null)
+            {
+                return methodList;
+            }
+
+            foreach (string missingMethod in state.Entry.missingBaseFor)
+            {
+                Label method = CreateLabel(
+                    name: null,
+                    className: MethodClassName,
+                    text: $"{missingMethod}: {BaseCallTypeScannerCore.GetMissingBaseConsequenceLine(missingMethod, state.FullName)}",
+                    bold: false
+                );
+                method.style.marginTop = 2;
+                methodList.Add(method);
+            }
+
+            return methodList;
+        }
+
+        private static Button CreateActionButton(
+            string name,
+            string text,
+            Action<MessageAwareComponentInspectorState> action,
+            MessageAwareComponentInspectorState state
+        )
+        {
+            Button button = new() { name = name, text = text };
+            button.AddToClassList(ActionButtonClassName);
+            button.AddToClassList(DxMessagingEditorTheme.ButtonGhostClassName);
+            if (action != null)
+            {
+                button.RegisterCallback<ClickEvent>(_ => action.Invoke(state));
+            }
+            button.SetEnabled(action != null);
+            return button;
+        }
+
+        private static void AddActionRow(VisualElement root, params Button[] buttons)
+        {
+            VisualElement row = new();
+            row.AddToClassList(ActionRowClassName);
+            row.style.flexDirection = FlexDirection.Row;
+            row.style.marginTop = 7;
+
+            foreach (Button button in buttons)
+            {
+                button.style.marginRight = 6;
+                row.Add(button);
+            }
+
+            root.Add(row);
+        }
+    }
+
+    internal readonly struct MessageAwareComponentInspectorViewActions
+    {
+        internal MessageAwareComponentInspectorViewActions(
+            Action<MessageAwareComponentInspectorState> onOpenScript,
+            Action<MessageAwareComponentInspectorState> onIgnoreType,
+            Action<MessageAwareComponentInspectorState> onStopIgnoring
+        )
+        {
+            OnOpenScript = onOpenScript;
+            OnIgnoreType = onIgnoreType;
+            OnStopIgnoring = onStopIgnoring;
+        }
+
+        internal static MessageAwareComponentInspectorViewActions None { get; } =
+            new(onOpenScript: null, onIgnoreType: null, onStopIgnoring: null);
+
+        internal Action<MessageAwareComponentInspectorState> OnOpenScript { get; }
+
+        internal Action<MessageAwareComponentInspectorState> OnIgnoreType { get; }
+
+        internal Action<MessageAwareComponentInspectorState> OnStopIgnoring { get; }
+    }
+#endif
+}

package/Editor/CustomEditors/MessageAwareComponentInspectorView.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7d6bd0a3d2954c51b8c017f57a7955a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/DxMessagingEditorPalette.cs

@@ -0,0 +1,66 @@
+#if UNITY_EDITOR
+namespace DxMessaging.Editor
+{
+    using System;
+    using UnityEngine;
+
+    internal static class DxMessagingEditorPalette
+    {
+        internal static readonly Color Amber = FromHex(0xf4, 0xa8, 0x36);
+        internal static readonly Color AmberSoft = FromHex(0xff, 0xd4, 0x8e);
+        internal static readonly Color Untargeted = FromHex(0x7f, 0xa6, 0xd8);
+        internal static readonly Color Targeted = FromHex(0xec, 0x46, 0x61);
+        internal static readonly Color Broadcast = FromHex(0x7f, 0xb8, 0x8a);
+        internal static readonly Color Trace = FromHex(0x7f, 0xa6, 0xd8);
+        internal static readonly Color TraceMessage = FromHex(0x7f, 0xb8, 0x8a);
+        internal static readonly Color TraceTarget = FromHex(0xff, 0xd4, 0x8e);
+        internal static readonly Color BorderSoft = new(0.14f, 0.17f, 0.22f, 0.32f);
+        internal static readonly Color Border = new(0.14f, 0.17f, 0.22f, 0.38f);
+        internal static readonly Color BorderPanel = new(0.14f, 0.17f, 0.22f, 0.42f);
+        internal static readonly Color BorderStrong = new(0.14f, 0.17f, 0.22f, 0.52f);
+        internal static readonly Color SelectedWash = new(0.96f, 0.66f, 0.21f, 0.1f);
+
+        internal const string UntargetedKind = "Untargeted";
+        internal const string TargetedKind = "Targeted";
+        internal const string BroadcastKind = "Broadcast";
+
+        internal static Color RouteKindColor(string routeKind)
+        {
+            switch (NormalizeRouteKind(routeKind))
+            {
+                case UntargetedKind:
+                    return Untargeted;
+                case TargetedKind:
+                    return Targeted;
+                case BroadcastKind:
+                    return Broadcast;
+                default:
+                    return Amber;
+            }
+        }
+
+        internal static string NormalizeRouteKind(string routeKind)
+        {
+            string value = string.IsNullOrWhiteSpace(routeKind) ? string.Empty : routeKind.Trim();
+            if (value.StartsWith(UntargetedKind, StringComparison.Ordinal))
+            {
+                return UntargetedKind;
+            }
+            if (value.StartsWith(TargetedKind, StringComparison.Ordinal))
+            {
+                return TargetedKind;
+            }
+            if (value.StartsWith(BroadcastKind, StringComparison.Ordinal))
+            {
+                return BroadcastKind;
+            }
+            return string.Empty;
+        }
+
+        private static Color FromHex(byte red, byte green, byte blue)
+        {
+            return new Color(red / 255f, green / 255f, blue / 255f, 1f);
+        }
+    }
+}
+#endif

package/Editor/DxMessagingEditorPalette.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a7e3720a22a0ca67c818278d404071e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/DxMessagingEditorTheme.cs

@@ -0,0 +1,200 @@
+#if UNITY_EDITOR
+namespace DxMessaging.Editor
+{
+    using System;
+    using UnityEditor;
+    using UnityEngine;
+    using UnityEngine.UIElements;
+
+    internal static class DxMessagingEditorTheme
+    {
+        internal const string PackageRoot = "Packages/com.wallstop-studios.dxmessaging";
+        internal const string TokensUssPath = PackageRoot + "/Editor/Theme/DxTokens.uss";
+        internal const string ThemeUssPath = PackageRoot + "/Editor/Theme/DxMessagingTheme.uss";
+        internal const string IconDir = PackageRoot + "/Editor/Icons";
+        internal const string Icon32FileName = "dxmessaging-icon-32.png";
+        internal const string Icon48FileName = "dxmessaging-icon-48.png";
+        internal const string Icon256FileName = "dxmessaging-icon-256.png";
+
+        internal const string ThemeClassName = "dx-theme";
+        internal const string LightSkinClassName = "dx-light";
+        internal const string DarkSkinClassName = "dx-dark";
+        internal const string WindowClassName = "dx-window";
+        internal const string ToolbarClassName = "dx-toolbar";
+        internal const string ToolButtonClassName = "dx-tool-btn";
+        internal const string SearchClassName = "dx-search";
+        internal const string CardClassName = "dx-card";
+        internal const string CardLabelClassName = "dx-card__label";
+        internal const string EmptyClassName = "dx-empty";
+        internal const string EmptyTitleClassName = "dx-empty__title";
+        internal const string EmptyBodyClassName = "dx-empty__body";
+        internal const string ButtonAccentClassName = "dx-btn-accent";
+        internal const string ButtonGhostClassName = "dx-btn-ghost";
+        internal const string AdmonitionClassName = "dx-admonition";
+        internal const string NoteClassName = "dx-note";
+        internal const string WarningClassName = "dx-warning";
+        internal const string TypeBadgeClassName = "dx-typebadge";
+        internal const string TypeBadgeUntargetedClassName = "dx-typebadge--u";
+        internal const string TypeBadgeTargetedClassName = "dx-typebadge--t";
+        internal const string TypeBadgeBroadcastClassName = "dx-typebadge--b";
+        internal const int CompleteBorderWidth = 1;
+
+        internal static void Apply(VisualElement root)
+        {
+            if (root == null)
+            {
+                return;
+            }
+
+            root.AddToClassList(ThemeClassName);
+            root.EnableInClassList(LightSkinClassName, !EditorGUIUtility.isProSkin);
+            root.EnableInClassList(DarkSkinClassName, EditorGUIUtility.isProSkin);
+            AddStyleSheet(root, TokensUssPath);
+            AddStyleSheet(root, ThemeUssPath);
+        }
+
+        internal static void ApplyWindow(VisualElement root)
+        {
+            Apply(root);
+            root?.AddToClassList(WindowClassName);
+        }
+
+        internal static void ApplyCompleteBorder(VisualElement element, Color borderColor)
+        {
+            if (element == null)
+            {
+                return;
+            }
+
+            element.style.borderTopWidth = CompleteBorderWidth;
+            element.style.borderRightWidth = CompleteBorderWidth;
+            element.style.borderBottomWidth = CompleteBorderWidth;
+            element.style.borderLeftWidth = CompleteBorderWidth;
+            element.style.borderTopColor = borderColor;
+            element.style.borderRightColor = borderColor;
+            element.style.borderBottomColor = borderColor;
+            element.style.borderLeftColor = borderColor;
+        }
+
+        internal static StyleSheet LoadTokensStylesheet()
+        {
+            return LoadStyleSheet(TokensUssPath);
+        }
+
+        internal static StyleSheet LoadThemeStylesheet()
+        {
+            return LoadStyleSheet(ThemeUssPath);
+        }
+
+        internal static Texture2D LoadIcon(string fileName = Icon32FileName)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                return null;
+            }
+
+            return AssetDatabase.LoadAssetAtPath<Texture2D>(IconDir + "/" + fileName);
+        }
+
+        internal static void AddRouteKindTypeBadgeClasses(VisualElement element, string routeKind)
+        {
+            if (element == null)
+            {
+                return;
+            }
+
+            element.AddToClassList(TypeBadgeClassName);
+            switch (DxMessagingEditorPalette.NormalizeRouteKind(routeKind))
+            {
+                case DxMessagingEditorPalette.UntargetedKind:
+                    element.AddToClassList(TypeBadgeUntargetedClassName);
+                    break;
+                case DxMessagingEditorPalette.TargetedKind:
+                    element.AddToClassList(TypeBadgeTargetedClassName);
+                    break;
+                case DxMessagingEditorPalette.BroadcastKind:
+                    element.AddToClassList(TypeBadgeBroadcastClassName);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Builds a themed empty-state block: a centered <c>.dx-empty</c> container holding an
+        /// optional bold <c>.dx-empty__title</c> headline and a muted, wrapping
+        /// <c>.dx-empty__body</c> detail label. Callers may name the title/body labels so tests
+        /// and callbacks can query them.
+        /// </summary>
+        internal static VisualElement CreateEmptyState(
+            string title,
+            string body,
+            string bodyName = null,
+            string titleName = null
+        )
+        {
+            VisualElement container = new();
+            container.AddToClassList(EmptyClassName);
+
+            if (!string.IsNullOrWhiteSpace(title))
+            {
+                Label titleLabel = new(title);
+                if (!string.IsNullOrWhiteSpace(titleName))
+                {
+                    titleLabel.name = titleName;
+                }
+                titleLabel.AddToClassList(EmptyTitleClassName);
+                container.Add(titleLabel);
+            }
+
+            if (!string.IsNullOrWhiteSpace(body))
+            {
+                Label bodyLabel = new(body);
+                if (!string.IsNullOrWhiteSpace(bodyName))
+                {
+                    bodyLabel.name = bodyName;
+                }
+                bodyLabel.AddToClassList(EmptyBodyClassName);
+                bodyLabel.style.whiteSpace = WhiteSpace.Normal;
+                container.Add(bodyLabel);
+            }
+
+            return container;
+        }
+
+        private static StyleSheet LoadStyleSheet(string path)
+        {
+            return AssetDatabase.LoadAssetAtPath<StyleSheet>(path);
+        }
+
+        private static void AddStyleSheet(VisualElement root, string path)
+        {
+            StyleSheet styleSheet = LoadStyleSheet(path);
+            if (styleSheet == null)
+            {
+                DxMessagingEditorLog.LogWarning(
+                    $"DxMessaging editor stylesheet was not found at '{path}'.",
+                    exception: null
+                );
+                return;
+            }
+
+            if (!HasStyleSheet(root, styleSheet))
+            {
+                root.styleSheets.Add(styleSheet);
+            }
+        }
+
+        private static bool HasStyleSheet(VisualElement root, StyleSheet styleSheet)
+        {
+            for (int index = 0; index < root.styleSheets.count; index++)
+            {
+                if (root.styleSheets[index] == styleSheet)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}
+#endif

package/Editor/DxMessagingEditorTheme.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8a7ce3f2ef322b9eab805825f0fa2e08
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/DxMessagingMenu.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/DxMessagingSceneBuildProcessor.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant: