fix(entity): move name position/alignment selectors to Appearance section

The entity widget's name_position and name_align fields controlled
visual placement of the name label but lived inline in the Content
section instead of Appearance, and had no test coverage for the
invert-condition panel that entity shares with tile. Extract them
into namePositionSelector()/nameAlignSelector() helpers matching the
existing selector pattern, move them into Appearance, and add entity
cases to the invert condition panel tests alongside the existing
tile ones.

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

Author: cryptomilk

custom_components/eink_dashboard/frontend/src/eink-dashboard-editor.ts

@@ -388,6 +388,46 @@ function boldValueSelector(): HaFormSchema {
   };
 }
 
+/**
+ * Name position dropdown selector (above or below the value).
+ *
+ * @returns A single ha-form schema entry.
+ */
+function namePositionSelector(): HaFormSchema {
+  return {
+    name: "name_position",
+    default: "bottom",
+    selector: {
+      select: {
+        options: [
+          { value: "bottom", label: "Bottom" },
+          { value: "top", label: "Top" },
+        ],
+      },
+    },
+  };
+}
+
+/**
+ * Name alignment dropdown selector.
+ *
+ * @returns A single ha-form schema entry.
+ */
+function nameAlignSelector(): HaFormSchema {
+  return {
+    name: "name_align",
+    default: "left",
+    selector: {
+      select: {
+        options: [
+          { value: "left", label: "Left" },
+          { value: "right", label: "Right" },
+        ],
+      },
+    },
+  };
+}
+
 /**
  * Icon style dropdown selector.
  *
@@ -757,30 +797,6 @@ export const SCHEMAS: Record<
         },
         { name: "attribute", selector: { text: {} } },
         { name: "unit", selector: { text: {} } },
-        {
-          name: "name_position",
-          default: "bottom",
-          selector: {
-            select: {
-              options: [
-                { value: "bottom", label: "Bottom" },
-                { value: "top", label: "Top" },
-              ],
-            },
-          },
-        },
-        {
-          name: "name_align",
-          default: "left",
-          selector: {
-            select: {
-              options: [
-                { value: "left", label: "Left" },
-                { value: "right", label: "Right" },
-              ],
-            },
-          },
-        },
       ],
     },
     {
@@ -797,7 +813,13 @@ export const SCHEMAS: Record<
       flatten: true,
       title: "Appearance",
       icon: "mdi:palette",
-      schema: [cardStyleSelector(), iconStyleSelector(), boldValueSelector()],
+      schema: [
+        cardStyleSelector(),
+        iconStyleSelector(),
+        boldValueSelector(),
+        namePositionSelector(),
+        nameAlignSelector(),
+      ],
     },
   ],
 

custom_components/eink_dashboard/frontend/test/eink-dashboard-editor.test.ts

@@ -595,7 +595,7 @@ describe("Visibility field", () => {
   });
 });
 
-// ── Invert condition panel (tile widgets) ───────────────────────────
+// ── Invert condition panel (tile/entity widgets) ────────────────────
 
 // Stub HA's <ha-card-conditions-editor> Lit component so the editor's
 // conditions panel builder takes its normal path instead of the
@@ -660,19 +660,29 @@ async function mountEditor(
   return editor;
 }
 
-describe("Invert condition panel (tile widgets)", () => {
+describe("Invert condition panel", () => {
   it("appears for tile widgets", async () => {
-    // The Invert panel is tile-specific — it must render when a
-    // tile widget row is expanded.
+    // The Invert panel is tile/entity-specific — it must render
+    // when a tile widget row is expanded.
     const editor = await mountEditor([
       { type: "tile", entity: "sensor.x" },
     ]);
     await expandWidget(editor, 0);
     expect(findPanelHeader(editor, "Invert")).toBeTruthy();
   });
 
-  it("does not appear for non-tile widgets", async () => {
-    // Non-tile widgets have no invert-on-condition rendering, so the
+  it("appears for entity widgets", async () => {
+    // The Invert panel is tile/entity-specific — it must render
+    // when an entity widget row is expanded.
+    const editor = await mountEditor([
+      { type: "entity", entity: "sensor.x" },
+    ]);
+    await expandWidget(editor, 0);
+    expect(findPanelHeader(editor, "Invert")).toBeTruthy();
+  });
+
+  it("does not appear for non-tile/entity widgets", async () => {
+    // Other widgets have no invert-on-condition rendering, so the
     // panel must be absent, while the Visibility panel still shows.
     const editor = await mountEditor([
       { type: "separator" },
@@ -733,6 +743,46 @@ describe("Invert condition panel (tile widgets)", () => {
     },
   );
 
+  it(
+    "value-changed on entity invert editor writes invert_condition",
+    async () => {
+      // Same write-back behaviour as tile, verified for the entity
+      // widget's invert panel.
+      const editor = await mountEditor([
+        { type: "entity", entity: "sensor.x" },
+      ]);
+      await expandWidget(editor, 0);
+
+      const header = findPanelHeader(editor, "Invert")!;
+      const panel = header.parentElement!;
+      const conditionsEditor = panel.querySelector(
+        "ha-card-conditions-editor",
+      )!;
+
+      let received: Widget[] | undefined;
+      editor.addEventListener(
+        "widget-change",
+        ((ev: CustomEvent<{ widgets: Widget[] }>) => {
+          received = ev.detail.widgets;
+        }) as EventListener,
+      );
+
+      const condition: StateCondition = {
+        condition: "state",
+        entity: "sensor.test",
+        state: "on",
+      };
+      conditionsEditor.dispatchEvent(
+        new CustomEvent("value-changed", {
+          detail: { value: [condition] },
+        }),
+      );
+
+      expect(received).toBeDefined();
+      expect(received![0].invert_condition).toEqual([condition]);
+    },
+  );
+
   it(
     "clearing invert conditions to an empty array deletes the key",
     async () => {
@@ -833,4 +883,59 @@ describe("Invert condition panel (tile widgets)", () => {
       expect(widget.visibility).toEqual([visibilityCondition]);
     },
   );
+
+  it(
+    "ha-form edit on an entity preserves invert_condition and visibility",
+    async () => {
+      // Same re-attach behaviour as tile, verified for the entity
+      // widget's ha-form.
+      const invertCondition: StateCondition = {
+        condition: "state",
+        entity: "sensor.invert-source",
+        state: "on",
+      };
+      const visibilityCondition: StateCondition = {
+        condition: "state",
+        entity: "sensor.visibility-source",
+        state: "on",
+      };
+      const editor = await mountEditor([
+        {
+          type: "entity",
+          entity: "sensor.x",
+          invert_condition: [invertCondition],
+          visibility: [visibilityCondition],
+        },
+      ]);
+      await expandWidget(editor, 0);
+
+      const form = editor.shadowRoot!.querySelector(
+        '.widget-item[data-index="0"] ha-form',
+      )!;
+
+      let received: Widget[] | undefined;
+      editor.addEventListener(
+        "widget-change",
+        ((ev: CustomEvent<{ widgets: Widget[] }>) => {
+          received = ev.detail.widgets;
+        }) as EventListener,
+      );
+
+      // Simulate ha-form emitting a rebuilt value that only contains
+      // schema-known fields — invert_condition/visibility are absent.
+      form.dispatchEvent(
+        new CustomEvent("value-changed", {
+          detail: { value: { entity: "sensor.y" } },
+        }),
+      );
+
+      expect(received).toBeDefined();
+      const widget = received![0] as Widget & {
+        invert_condition?: unknown;
+      };
+      expect(widget.entity).toBe("sensor.y");
+      expect(widget.invert_condition).toEqual([invertCondition]);
+      expect(widget.visibility).toEqual([visibilityCondition]);
+    },
+  );
 });