@eclipse-docks/core 0.7.108 → 0.7.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-docks/core",
-  "version": "0.7.108",
+  "version": "0.7.110",
   "description": "Eclipse Docks platform core: registries, services, parts, widgets, and API",
   "type": "module",
   "license": "EPL-2.0",

package/src/api/services.ts

@@ -35,8 +35,14 @@ export {
     navigableInfoDialog,
     confirmDialog,
     promptDialog,
+    formDialog,
+    formDialogRequired,
+    validateFormDialogFields,
     filebrowserDialog,
-    type NavigableDialogAction
+    type NavigableDialogAction,
+    type FormDialogField,
+    type FormDialogFieldType,
+    type FormDialogOptions,
 } from '../dialogs';
 export { 
     toastInfo,

package/src/api/types.ts

@@ -36,7 +36,10 @@ export type {
 export type {
     NavigableDialogAction,
     FilebrowserDialogMode,
-    FilebrowserDialogState
+    FilebrowserDialogState,
+    FormDialogField,
+    FormDialogFieldType,
+    FormDialogOptions,
 } from '../dialogs';
 export type {
     TreeNode,

package/src/components/command.ts

@@ -60,6 +60,16 @@ export class DocksCommand extends DocksWidget {
     @state()
     private dropdownContributions: Contribution[] = []
 
+    private closeDropdown(dropdown: { open?: boolean } | null | undefined) {
+        if (dropdown && dropdown.open !== undefined) {
+            dropdown.open = false
+        }
+    }
+
+    private closeParentDropdown() {
+        this.closeDropdown(this.closest('wa-dropdown') as { open?: boolean } | null)
+    }
+
     private handleClick(event?: Event) {
         if (this.disabled) return
 
@@ -67,27 +77,20 @@ export class DocksCommand extends DocksWidget {
             event.stopPropagation()
         }
 
+        this.closeParentDropdown()
+
         if (this.action) {
             this.action(event)
             return
         }
 
         if (this.cmd) {
-            const dropdown = this.closest('wa-dropdown') as any;
-            if (dropdown && dropdown.open !== undefined) {
-                dropdown.open = false;
-            }
             void this.executeCommand(this.cmd, this.params);
         }
     }
 
     private handleSelect(event: CustomEvent) {
-        // Close dropdown immediately when any item is selected
-        // This ensures the dropdown is hidden before the command executes
-        const dropdown = event.target as any;
-        if (dropdown && dropdown.open !== undefined) {
-            dropdown.open = false;
-        }
+        this.closeDropdown(event.target as { open?: boolean })
     }
 
     private isInDropdown(): boolean {

package/src/core/dialogservice.ts

@@ -182,8 +182,13 @@ class DialogService {
             }
             const stateWithClose = { ...state, close: cleanup };
 
+            const dialogLabel =
+                state && typeof state === 'object' && typeof (state as { label?: unknown }).label === 'string'
+                    ? (state as { label: string }).label
+                    : (contribution.label || dialogId);
+
             const template = html`
-                <wa-dialog label="${contribution.label || dialogId}" open @wa-request-close=${cleanup}>
+                <wa-dialog label="${dialogLabel}" open @wa-request-close=${cleanup}>
                     <style>
                         .dialog-service-content {
                             display: flex;

package/src/dialogs/form-dialog.ts

@@ -0,0 +1,239 @@
+import { html, css, PropertyValues } from "lit";
+import { customElement, state, property } from "lit/decorators.js";
+import { DocksDialogContent } from "../parts/dialog-content";
+import { contributionRegistry } from "../core/contributionregistry";
+import {
+    DIALOG_CONTRIBUTION_TARGET,
+    OK_BUTTON,
+    CANCEL_BUTTON,
+    dialogService,
+} from "../core/dialogservice";
+
+/** HTML input types supported by {@link formDialog}. */
+export type FormDialogFieldType = "text" | "password" | "url" | "email" | "number";
+
+export interface FormDialogField {
+    /** Key in the returned values record. */
+    name: string;
+    label: string;
+    type?: FormDialogFieldType;
+    value?: string;
+    placeholder?: string;
+    /** When false, empty values are allowed. Defaults to true. */
+    required?: boolean;
+}
+
+export interface FormDialogOptions {
+    /** Dialog window title (shown on `wa-dialog`). */
+    label: string;
+    fields: FormDialogField[];
+    /** Optional message above the fields (plain text or markdown). */
+    message?: string;
+    markdown?: boolean;
+}
+
+interface FormDialogState extends FormDialogOptions {
+    resolve: (values: Record<string, string> | null) => void;
+}
+
+@customElement("docks-form-dialog-content")
+export class DocksFormDialogContent extends DocksDialogContent {
+    @property({ attribute: false })
+    fields: FormDialogField[] = [];
+
+    @property({ type: String })
+    message = "";
+
+    @property({ type: Boolean })
+    markdown = false;
+
+    @state()
+    private values: Record<string, string> = {};
+
+    @state()
+    private validationError = "";
+
+    static styles = [
+        ...DocksDialogContent.styles,
+        css`
+            .form-fields {
+                display: flex;
+                flex-direction: column;
+                gap: 0.75rem;
+                min-width: 22rem;
+            }
+
+            .field label {
+                display: flex;
+                flex-direction: column;
+                gap: 0.25rem;
+                font-size: var(--wa-font-size-s);
+            }
+
+            .field-label {
+                font-weight: 500;
+                color: var(--wa-color-text-normal);
+            }
+
+            wa-input {
+                width: 100%;
+            }
+
+            .validation-error {
+                color: var(--wa-color-danger-600, #dc2626);
+                font-size: var(--wa-font-size-s);
+            }
+        `,
+    ];
+
+    async firstUpdated(changedProperties: PropertyValues) {
+        super.firstUpdated(changedProperties);
+        const initial: Record<string, string> = {};
+        for (const field of this.fields) {
+            initial[field.name] = field.value ?? "";
+        }
+        this.values = initial;
+
+        await this.updateComplete;
+        const input = this.shadowRoot?.querySelector("wa-input");
+        const inputEl = (input as HTMLElement & { shadowRoot?: ShadowRoot })?.shadowRoot?.querySelector(
+            "input",
+        );
+        inputEl?.focus();
+    }
+
+    getResult(): Record<string, string> {
+        return { ...this.values };
+    }
+
+    setValidationError(message: string): void {
+        this.validationError = message;
+    }
+
+    private updateField(name: string, value: string): void {
+        this.values = { ...this.values, [name]: value };
+        if (this.validationError) this.validationError = "";
+    }
+
+    private handleKeyDown(event: KeyboardEvent): void {
+        if (event.key === "Enter") {
+            event.preventDefault();
+            this.dispatchEvent(new CustomEvent("dialog-ok", { bubbles: true, composed: true }));
+        } else if (event.key === "Escape") {
+            event.preventDefault();
+            this.dispatchEvent(new CustomEvent("dialog-cancel", { bubbles: true, composed: true }));
+        }
+    }
+
+    render() {
+        return html`
+            ${this.message ? this.renderMessage(this.message, this.markdown) : null}
+            <div class="form-fields" @keydown=${this.handleKeyDown}>
+                ${this.fields.map(
+                    (field) => html`
+                        <div class="field">
+                            <label>
+                                <span class="field-label">${field.label}</span>
+                                <wa-input
+                                    type=${field.type ?? "text"}
+                                    .value=${this.values[field.name] ?? ""}
+                                    placeholder=${field.placeholder ?? ""}
+                                    @input=${(event: Event) =>
+                                        this.updateField(
+                                            field.name,
+                                            (event.target as HTMLInputElement).value,
+                                        )}
+                                ></wa-input>
+                            </label>
+                        </div>
+                    `,
+                )}
+                ${this.validationError
+                    ? html`<div class="validation-error">${this.validationError}</div>`
+                    : null}
+            </div>
+        `;
+    }
+}
+
+declare global {
+    interface HTMLElementTagNameMap {
+        "docks-form-dialog-content": DocksFormDialogContent;
+    }
+}
+
+function trimValues(values: Record<string, string>): Record<string, string> {
+    return Object.fromEntries(
+        Object.entries(values).map(([key, value]) => [key, value.trim()]),
+    );
+}
+
+function findFormDialogContent(): DocksFormDialogContent | null {
+    return document.querySelector("docks-form-dialog-content");
+}
+
+/** Validates required fields; returns an error message or null if valid. */
+export function validateFormDialogFields(
+    fields: FormDialogField[],
+    values: Record<string, string>,
+): string | null {
+    for (const field of fields) {
+        if (field.required === false) continue;
+        if (!values[field.name]?.trim()) {
+            return `${field.label} is required.`;
+        }
+    }
+    return null;
+}
+
+contributionRegistry.registerContribution(DIALOG_CONTRIBUTION_TARGET, {
+    id: "form",
+    label: "Form",
+    buttons: [OK_BUTTON, CANCEL_BUTTON],
+    component: (state?: FormDialogState) => {
+        if (!state) {
+            return html`<div>Error: No form dialog state</div>`;
+        }
+
+        return html`
+            <docks-form-dialog-content
+                .message=${state.message ?? ""}
+                .markdown=${state.markdown ?? false}
+                .fields=${state.fields}
+            ></docks-form-dialog-content>
+        `;
+    },
+    onButton: async (id: string, result: unknown, state?: FormDialogState) => {
+        if (!state) {
+            return true;
+        }
+
+        if (id === "ok") {
+            const values = trimValues((result ?? {}) as Record<string, string>);
+            const error = validateFormDialogFields(state.fields, values);
+            if (error) {
+                findFormDialogContent()?.setValidationError(error);
+                return false;
+            }
+            state.resolve(values);
+        } else {
+            state.resolve(null);
+        }
+
+        return true;
+    },
+});
+
+export function formDialog(options: FormDialogOptions): Promise<Record<string, string> | null> {
+    return new Promise((resolve) => {
+        dialogService.open("form", { ...options, resolve });
+    });
+}
+
+export async function formDialogRequired(
+    options: FormDialogOptions,
+): Promise<Record<string, string>> {
+    const values = await formDialog(options);
+    if (!values) throw new Error("Cancelled");
+    return values;
+}

package/src/dialogs/index.ts

@@ -1,4 +1,12 @@
 export { promptDialog } from './prompt-dialog';
+export {
+  formDialog,
+  formDialogRequired,
+  validateFormDialogFields,
+  type FormDialogField,
+  type FormDialogFieldType,
+  type FormDialogOptions,
+} from './form-dialog';
 export { infoDialog } from './info-dialog';
 export { confirmDialog } from './confirm-dialog';
 export { navigableInfoDialog, type NavigableDialogAction } from './navigable-info-dialog';

package/src/parts/tabs.ts

@@ -469,13 +469,27 @@ export class DocksTabs extends DocksContainer {
             overflow: hidden;
         }
 
-        :host(:is([placement="top"], [placement="bottom"])) wa-tab-group::part(base) {
+        /* Top: nav (order 0) → row 1 auto, body (order 2) → row 2 1fr. */
+        :host([placement="top"]) wa-tab-group::part(base) {
             display: grid;
             grid-template-rows: auto minmax(0, 1fr);
             height: 100%;
             width: 100%;
         }
 
+        /* Bottom: body (order 1) → row 1 1fr, nav (order 2) → row 2 auto. */
+        :host([placement="bottom"]) wa-tab-group::part(base) {
+            display: grid;
+            grid-template-rows: minmax(0, 1fr) auto;
+            height: 100%;
+            width: 100%;
+        }
+
+        :host([placement="bottom"]) wa-tab-group::part(body) {
+            min-height: 0;
+            overflow: hidden;
+        }
+
         :host(:is([placement="start"], [placement="end"])) wa-tab-group::part(base) {
             height: 100%;
             width: 100%;