@design.estate/wcctools 5.1.0

package/ts_web/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@design.estate/wcctools',
+  version: '5.1.0',
+  description: 'A set of web component tools for creating element catalogues, enabling the structured development and documentation of custom elements and pages.'
+}

package/ts_web/elements/wcc-contextmenu.ts

@@ -0,0 +1,291 @@
+import { DeesElement, property, html, customElement, type TemplateResult, state, css, cssManager } from '@design.estate/dees-element';
+
+export interface IContextMenuItem {
+  name: string;
+  iconName?: string;
+  action: () => void | Promise<void>;
+  disabled?: boolean;
+}
+
+export interface IContextMenuOptions {
+  /** The element the menu belongs to: focus returns to it when the menu closes */
+  ownerElement?: HTMLElement;
+}
+
+@customElement('wcc-contextmenu')
+export class WccContextmenu extends DeesElement {
+  /**
+   * Show a context menu at the event's position. The menu takes focus (its first item),
+   * is operated with the arrow keys, Home/End, Enter/Space and Escape/Tab, and returns
+   * focus to `ownerElement` when it closes from the keyboard or after an action.
+   */
+  public static async show(
+    event: MouseEvent,
+    menuItems: IContextMenuItem[],
+    options: IContextMenuOptions = {}
+  ): Promise<void> {
+    event.preventDefault();
+    event.stopPropagation();
+
+    // Remove any existing context menu
+    const existing = document.querySelector('wcc-contextmenu');
+    if (existing) {
+      existing.remove();
+    }
+
+    const menu = new WccContextmenu();
+    menu.menuItems = menuItems;
+    menu.x = event.clientX;
+    menu.y = event.clientY;
+    menu.ownerElement = options.ownerElement ?? null;
+
+    document.body.appendChild(menu);
+
+    // Wait for render then adjust position if needed
+    await menu.updateComplete;
+    menu.adjustPosition();
+    menu.focusItem(0);
+  }
+
+  /** Focus returns here when the menu closes from the keyboard or after an action */
+  private ownerElement: HTMLElement | null = null;
+  private closing = false;
+
+  @property({ type: Array })
+  accessor menuItems: IContextMenuItem[] = [];
+
+  @property({ type: Number })
+  accessor x: number = 0;
+
+  @property({ type: Number })
+  accessor y: number = 0;
+
+  @state()
+  accessor visible: boolean = false;
+
+  private boundHandleOutsideClick = this.handleOutsideClick.bind(this);
+  private boundHandleKeydown = this.handleKeydown.bind(this);
+
+  public static styles = [
+    css`
+      :host {
+        position: fixed;
+        z-index: 10000;
+        opacity: 0;
+        transform: scale(0.95) translateY(-5px);
+        transition: opacity 0.15s ease, transform 0.15s ease;
+        pointer-events: none;
+      }
+
+      :host(.visible) {
+        opacity: 1;
+        transform: scale(1) translateY(0);
+        pointer-events: auto;
+      }
+
+      .menu {
+        min-width: 160px;
+        background: #0f0f0f;
+        border: 1px solid rgba(255, 255, 255, 0.1);
+        border-radius: 6px;
+        box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
+        padding: 4px 0;
+        font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
+        font-size: 12px;
+      }
+
+      .menu-item {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding: 8px 12px;
+        color: #ccc;
+        cursor: pointer;
+        transition: background 0.1s ease;
+        user-select: none;
+      }
+
+      .menu {
+        outline: none;
+      }
+
+      .menu-item:hover,
+      .menu-item:focus {
+        background: rgba(59, 130, 246, 0.15);
+        color: #fff;
+        outline: none;
+      }
+
+      .menu-item:focus-visible {
+        box-shadow: inset 0 0 0 2px #3b82f6;
+      }
+
+      .menu-item.disabled {
+        opacity: 0.4;
+        cursor: not-allowed;
+        pointer-events: none;
+      }
+
+      .menu-item .icon {
+        font-family: 'Material Symbols Outlined';
+        font-size: 16px;
+        font-weight: normal;
+        font-style: normal;
+        line-height: 1;
+        letter-spacing: normal;
+        text-transform: none;
+        white-space: nowrap;
+        word-wrap: normal;
+        direction: ltr;
+        font-variation-settings: 'FILL' 0, 'wght' 300, 'GRAD' 0, 'opsz' 24;
+        opacity: 0.7;
+      }
+
+      .menu-item:hover .icon {
+        opacity: 1;
+      }
+
+      .menu-item .label {
+        flex: 1;
+      }
+    `
+  ];
+
+  public render(): TemplateResult {
+    return html`
+      <div class="menu" role="menu" tabindex="-1" @keydown=${this.handleMenuKeydown}>
+        ${this.menuItems.map(item => html`
+          <div
+            class="menu-item ${item.disabled ? 'disabled' : ''}"
+            role="menuitem"
+            tabindex="-1"
+            aria-disabled=${item.disabled ? 'true' : 'false'}
+            @click=${() => this.handleItemClick(item)}
+          >
+            ${item.iconName ? html`<span class="icon" aria-hidden="true">${item.iconName}</span>` : null}
+            <span class="label">${item.name}</span>
+          </div>
+        `)}
+      </div>
+    `;
+  }
+
+  async connectedCallback() {
+    await super.connectedCallback();
+    // Delay adding listeners to avoid immediate close
+    requestAnimationFrame(() => {
+      document.addEventListener('click', this.boundHandleOutsideClick);
+      document.addEventListener('contextmenu', this.boundHandleOutsideClick);
+      document.addEventListener('keydown', this.boundHandleKeydown);
+      this.classList.add('visible');
+    });
+  }
+
+  async disconnectedCallback() {
+    await super.disconnectedCallback();
+    document.removeEventListener('click', this.boundHandleOutsideClick);
+    document.removeEventListener('contextmenu', this.boundHandleOutsideClick);
+    document.removeEventListener('keydown', this.boundHandleKeydown);
+  }
+
+  private adjustPosition() {
+    const rect = this.getBoundingClientRect();
+    const windowWidth = window.innerWidth;
+    const windowHeight = window.innerHeight;
+
+    let x = this.x;
+    let y = this.y;
+
+    // Adjust if menu goes off right edge
+    if (x + rect.width > windowWidth - 10) {
+      x = windowWidth - rect.width - 10;
+    }
+
+    // Adjust if menu goes off bottom edge
+    if (y + rect.height > windowHeight - 10) {
+      y = windowHeight - rect.height - 10;
+    }
+
+    // Ensure not off left or top
+    if (x < 10) x = 10;
+    if (y < 10) y = 10;
+
+    this.style.left = `${x}px`;
+    this.style.top = `${y}px`;
+  }
+
+  private handleOutsideClick(e: Event) {
+    const path = e.composedPath();
+    if (!path.includes(this)) {
+      this.close();
+    }
+  }
+
+  private handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape') {
+      this.close(true);
+    }
+  }
+
+  private getEnabledItems(): HTMLElement[] {
+    return Array.from(this.shadowRoot?.querySelectorAll<HTMLElement>('.menu-item:not(.disabled)') ?? []);
+  }
+
+  /** Focus an enabled item by index (wrapping); the menu itself if there is none */
+  private focusItem(indexArg: number) {
+    const items = this.getEnabledItems();
+    if (items.length === 0) {
+      (this.shadowRoot?.querySelector('.menu') as HTMLElement | null)?.focus({ preventScroll: true });
+      return;
+    }
+    const index = ((indexArg % items.length) + items.length) % items.length;
+    items[index].focus({ preventScroll: true });
+  }
+
+  private handleMenuKeydown = (e: KeyboardEvent) => {
+    const items = this.getEnabledItems();
+    const current = items.indexOf(this.shadowRoot?.activeElement as HTMLElement);
+    switch (e.key) {
+      case 'ArrowDown':
+        this.focusItem(current + 1);
+        break;
+      case 'ArrowUp':
+        this.focusItem(current < 0 ? -1 : current - 1);
+        break;
+      case 'Home':
+        this.focusItem(0);
+        break;
+      case 'End':
+        this.focusItem(-1);
+        break;
+      case 'Enter':
+      case ' ':
+        if (current >= 0) items[current].click();
+        break;
+      case 'Escape':
+      case 'Tab':
+        this.close(true);
+        break;
+      default:
+        return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+  };
+
+  private async handleItemClick(item: IContextMenuItem) {
+    if (item.disabled) return;
+    await item.action();
+    this.close(true);
+  }
+
+  private close(returnFocus = false) {
+    if (this.closing) return;
+    this.closing = true;
+    if (returnFocus && this.ownerElement?.isConnected) {
+      this.ownerElement.focus({ preventScroll: true });
+    }
+    this.classList.remove('visible');
+    setTimeout(() => this.remove(), 150);
+  }
+}