@openelement/ui 0.41.0-alpha.1

package/src/open-dialog.js

@@ -0,0 +1,235 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-dialog
+ *
+ * Dialog component using native <dialog> element + popover API.
+ * Per WHATWG HTML Living Standard sections 4.11.4 (dialog) and 6.9.2 (popover).
+ *
+ * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart overlay - The dialog backdrop/element
+ * @csspart header -The header bar
+ * @csspart close -The close button
+ * @csspart body -The content area (<slot>)
+ * @csspart footer -The optional footer slot
+ *
+ * Usage:
+ * ```html
+ * <open-dialog>
+ *   <button slot="trigger">Open Dialog</button>
+ *   <div>Dialog content here</div>
+ * </open-dialog>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+import { escapeAttr, escapeHtml } from '@openelement/core';
+export const tagName = 'open-dialog';
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: inline-block;
+  }
+
+  ::slotted([slot="trigger"]) {
+    cursor: pointer;
+  }
+
+  dialog {
+    border: var(--border-size-1) solid var(--gray-3);
+    border-radius: var(--radius-3);
+    background: var(--gray-0);
+    color: var(--gray-9);
+    padding: var(--size-6);
+    max-width: min(90vw, 480px);
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);
+    font-family: var(--font-sans);
+  }
+
+  dialog::backdrop {
+    background: rgba(0, 0, 0, 0.4);
+    backdrop-filter: blur(4px);
+  }
+
+  dialog[open] {
+    animation: dialogFadeIn 0.2s ease-out;
+  }
+
+  @keyframes dialogFadeIn {
+    from { opacity: 0; transform: translateY(-8px); }
+    to { opacity: 1; transform: translateY(0); }
+  }
+
+  .dialog-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--size-4);
+  }
+
+  .dialog-title {
+    font-size: var(--font-size-2);
+    font-weight: var(--font-weight-6);
+    color: var(--gray-9);
+    margin: 0;
+  }
+
+  .dialog-close {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: var(--gray-5);
+    font-size: var(--font-size-2);
+    line-height: var(--font-lineheight-1);
+    padding: var(--size-1);
+    border-radius: var(--radius-1);
+    transition: color 0.15s ease;
+  }
+
+  .dialog-close:hover {
+    color: var(--gray-9);
+    background: rgba(83,74,183,0.06);
+  }
+
+  .dialog-body {
+    font-size: var(--font-size-1);
+    color: var(--gray-7);
+    line-height: var(--font-lineheight-3);
+  }
+
+  .dialog-footer {
+    margin-top: var(--size-5);
+    display: flex;
+    justify-content: flex-end;
+    gap: var(--size-2);
+  }
+
+  :host(:state(open)) dialog {
+    display: block;
+  }
+`);
+export class OpenDialog extends OpenElement {
+  static styles = [
+    sheet
+  ];
+  static delegatesFocus = true;
+  static observedAttributes = [
+    'open',
+    'label'
+  ];
+  static _originalInertStates = new WeakMap();
+  render() {
+    const label = this._esc(this.getAttribute('label') || '');
+    return <>
+        <slot name='trigger' onClick={()=>this._handleTrigger()}></slot>
+        <dialog aria-label={this.getAttribute('label') || ''} part='overlay' onCancel={(e)=>this._handleCancel(e)} onClose={()=>this._handleClose()}>
+          <div className='dialog-header' part='header'>
+            <h2 className='dialog-title'>{label}</h2>
+            <button type='button' className='dialog-close' part='close' aria-label='Close' onClick={()=>this._handleClose()}>
+              &times;
+            </button>
+          </div>
+          <div className='dialog-body' part='body'>
+            <slot></slot>
+          </div>
+          <div className='dialog-footer' part='footer'>
+            <slot name='footer'></slot>
+          </div>
+        </dialog>
+      </>;
+  }
+  attributeChangedCallback(name, old, val) {
+    if (old === val) return;
+    if (name === 'open') {
+      this._updateStates();
+      this._syncDialogElement();
+      this._syncInert();
+    }
+  }
+  _updateStates() {
+    if (!this._internals?.states) return;
+    if (this.hasAttribute('open')) {
+      this._internals.states.add('open');
+      this._internals.states.delete('closed');
+    } else {
+      this._internals.states.delete('open');
+      this._internals.states.add('closed');
+    }
+  }
+  show() {
+    this.setAttribute('open', '');
+  }
+  close() {
+    this.removeAttribute('open');
+  }
+  toggle() {
+    if (this.hasAttribute('open')) this.removeAttribute('open');
+    else this.setAttribute('open', '');
+  }
+  _syncDialogElement() {
+    const dialog1 = this.shadowRoot?.querySelector('dialog');
+    if (!dialog1) return;
+    if (this.hasAttribute('open') && !dialog1.open) {
+      dialog1.showModal();
+    } else if (!this.hasAttribute('open') && dialog1.open) {
+      dialog1.close();
+    }
+  }
+  _syncInert() {
+    const parent = this.parentNode;
+    if (!parent) return;
+    const parentEl = parent instanceof ShadowRoot ? parent.host.parentNode : parent;
+    if (!parentEl) return;
+    const children = [
+      ...parentEl.children
+    ];
+    const open = this.hasAttribute('open');
+    if (open) {
+      for (const child of children){
+        if (child !== this) {
+          if (!OpenDialog._originalInertStates.has(child)) {
+            OpenDialog._originalInertStates.set(child, child.hasAttribute('inert'));
+          }
+          child.setAttribute('inert', '');
+        }
+      }
+    } else {
+      for (const child of children){
+        if (child !== this) {
+          const wasOriginallyInert = OpenDialog._originalInertStates.get(child);
+          if (wasOriginallyInert) child.setAttribute('inert', '');
+          else child.removeAttribute('inert');
+          OpenDialog._originalInertStates.delete(child);
+        }
+      }
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    if (this.hasAttribute('open')) this._syncInert();
+  }
+  _handleClose() {
+    this.removeAttribute('open');
+    this._updateStates();
+    this._syncDialogElement();
+    this._syncInert();
+    this.dispatchEvent(new CustomEvent('open-dialog-close', {
+      bubbles: true,
+      composed: true
+    }));
+  }
+  _handleCancel(e) {
+    e.preventDefault();
+    this._handleClose();
+  }
+  _handleTrigger() {
+    this.toggle();
+  }
+  _esc = escapeHtml;
+  _escAttr = escapeAttr;
+}
+export default OpenDialog;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenDialog);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/open-dialog.tsx"],"sourcesContent":["/** @jsxImportSource @openelement/core */\n/**\n * @openelement/ui - open-dialog\n *\n * Dialog component using native <dialog> element + popover API.\n * Per WHATWG HTML Living Standard sections 4.11.4 (dialog) and 6.9.2 (popover).\n *\n * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).\n * v0.24.1: Migrated from html`` template to JSX (ADR-0057).\n *\n * @csspart overlay - The dialog backdrop/element\n * @csspart header -The header bar\n * @csspart close -The close button\n * @csspart body -The content area (<slot>)\n * @csspart footer -The optional footer slot\n *\n * Usage:\n * ```html\n * <open-dialog>\n *   <button slot=\"trigger\">Open Dialog</button>\n *   <div>Dialog content here</div>\n * </open-dialog>\n * ```\n */\n\nimport { OpenElement } from '@openelement/element';\nimport { StyleSheet, type StyleSheetLike } from '@openelement/core/style-sheet';\nimport { escapeAttr, escapeHtml } from '@openelement/core';\n\nexport const tagName = 'open-dialog';\n\nconst sheet: StyleSheetLike = new StyleSheet();\nsheet.replaceSync(`\n  :host {\n    display: inline-block;\n  }\n\n  ::slotted([slot=\"trigger\"]) {\n    cursor: pointer;\n  }\n\n  dialog {\n    border: var(--border-size-1) solid var(--gray-3);\n    border-radius: var(--radius-3);\n    background: var(--gray-0);\n    color: var(--gray-9);\n    padding: var(--size-6);\n    max-width: min(90vw, 480px);\n    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);\n    font-family: var(--font-sans);\n  }\n\n  dialog::backdrop {\n    background: rgba(0, 0, 0, 0.4);\n    backdrop-filter: blur(4px);\n  }\n\n  dialog[open] {\n    animation: dialogFadeIn 0.2s ease-out;\n  }\n\n  @keyframes dialogFadeIn {\n    from { opacity: 0; transform: translateY(-8px); }\n    to { opacity: 1; transform: translateY(0); }\n  }\n\n  .dialog-header {\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n    margin-bottom: var(--size-4);\n  }\n\n  .dialog-title {\n    font-size: var(--font-size-2);\n    font-weight: var(--font-weight-6);\n    color: var(--gray-9);\n    margin: 0;\n  }\n\n  .dialog-close {\n    background: none;\n    border: none;\n    cursor: pointer;\n    color: var(--gray-5);\n    font-size: var(--font-size-2);\n    line-height: var(--font-lineheight-1);\n    padding: var(--size-1);\n    border-radius: var(--radius-1);\n    transition: color 0.15s ease;\n  }\n\n  .dialog-close:hover {\n    color: var(--gray-9);\n    background: rgba(83,74,183,0.06);\n  }\n\n  .dialog-body {\n    font-size: var(--font-size-1);\n    color: var(--gray-7);\n    line-height: var(--font-lineheight-3);\n  }\n\n  .dialog-footer {\n    margin-top: var(--size-5);\n    display: flex;\n    justify-content: flex-end;\n    gap: var(--size-2);\n  }\n\n  :host(:state(open)) dialog {\n    display: block;\n  }\n`);\n\nexport class OpenDialog extends OpenElement {\n  static override styles = [sheet];\n  static override delegatesFocus = true;\n  static override observedAttributes = ['open', 'label'];\n\n  private static _originalInertStates = new WeakMap<Element, boolean>();\n\n  override render(): ReturnType<typeof OpenElement.prototype.render> {\n    const label = this._esc(this.getAttribute('label') || '');\n    return (\n      <>\n        <slot name='trigger' onClick={() => this._handleTrigger()}></slot>\n        <dialog\n          aria-label={this.getAttribute('label') || ''}\n          part='overlay'\n          onCancel={(e: Event) => this._handleCancel(e)}\n          onClose={() => this._handleClose()}\n        >\n          <div className='dialog-header' part='header'>\n            <h2 className='dialog-title'>{label}</h2>\n            <button\n              type='button'\n              className='dialog-close'\n              part='close'\n              aria-label='Close'\n              onClick={() => this._handleClose()}\n            >\n              &times;\n            </button>\n          </div>\n          <div className='dialog-body' part='body'>\n            <slot></slot>\n          </div>\n          <div className='dialog-footer' part='footer'>\n            <slot name='footer'></slot>\n          </div>\n        </dialog>\n      </>\n    );\n  }\n\n  override attributeChangedCallback(name: string, old: string | null, val: string | null): void {\n    if (old === val) return;\n    if (name === 'open') {\n      this._updateStates();\n      this._syncDialogElement();\n      this._syncInert();\n    }\n  }\n\n  private _updateStates(): void {\n    if (!this._internals?.states) return;\n    if (this.hasAttribute('open')) {\n      this._internals.states.add('open');\n      this._internals.states.delete('closed');\n    } else {\n      this._internals.states.delete('open');\n      this._internals.states.add('closed');\n    }\n  }\n\n  show(): void {\n    this.setAttribute('open', '');\n  }\n\n  close(): void {\n    this.removeAttribute('open');\n  }\n\n  toggle(): void {\n    if (this.hasAttribute('open')) this.removeAttribute('open');\n    else this.setAttribute('open', '');\n  }\n\n  private _syncDialogElement(): void {\n    const dialog = this.shadowRoot?.querySelector('dialog');\n    if (!dialog) return;\n    if (this.hasAttribute('open') && !dialog.open) {\n      dialog.showModal();\n    } else if (!this.hasAttribute('open') && dialog.open) {\n      dialog.close();\n    }\n  }\n\n  private _syncInert(): void {\n    const parent = this.parentNode;\n    if (!parent) return;\n    const parentEl = parent instanceof ShadowRoot\n      ? (parent.host.parentNode as Element)\n      : (parent as Element);\n    if (!parentEl) return;\n\n    const children = [...parentEl.children];\n    const open = this.hasAttribute('open');\n    if (open) {\n      for (const child of children) {\n        if (child !== this) {\n          if (!OpenDialog._originalInertStates.has(child)) {\n            OpenDialog._originalInertStates.set(child, child.hasAttribute('inert'));\n          }\n          child.setAttribute('inert', '');\n        }\n      }\n    } else {\n      for (const child of children) {\n        if (child !== this) {\n          const wasOriginallyInert = OpenDialog._originalInertStates.get(child);\n          if (wasOriginallyInert) child.setAttribute('inert', '');\n          else child.removeAttribute('inert');\n          OpenDialog._originalInertStates.delete(child);\n        }\n      }\n    }\n  }\n\n  override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    if (this.hasAttribute('open')) this._syncInert();\n  }\n\n  private _handleClose(): void {\n    this.removeAttribute('open');\n    this._updateStates();\n    this._syncDialogElement();\n    this._syncInert();\n    this.dispatchEvent(new CustomEvent('open-dialog-close', { bubbles: true, composed: true }));\n  }\n\n  private _handleCancel(e: Event): void {\n    e.preventDefault();\n    this._handleClose();\n  }\n\n  private _handleTrigger(): void {\n    this.toggle();\n  }\n\n  private _esc = escapeHtml;\n  private _escAttr = escapeAttr;\n}\n\nexport default OpenDialog;\n\n// Guard: idempotent across SSR paths\nif (typeof customElements !== 'undefined' && !customElements.get(tagName)) {\n  customElements.define(tagName, OpenDialog);\n}\n"],"names":[],"mappings":"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"}

package/src/open-dropdown.d.ts

@@ -0,0 +1,25 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-dropdown
+ *
+ * DaisyUI-style dropdown using DsdElement + Signals.
+ * State is reflected to the host `data-open` attribute.
+ * CSS uses `:host([data-open="true"])` to control visibility.
+ *
+ * Usage:
+ * ```html
+ * <open-dropdown>
+ *   <button slot="trigger">Open</button>
+ *   <div>Dropdown content</div>
+ * </open-dropdown>
+ * ```
+ *
+ * @slot trigger - Click target to toggle the dropdown
+ * @slot - Dropdown content (shown when open)
+ */ import { OpenElement, type VNode } from '@openelement/element';
+import { daisyClassSheet } from "./daisy-classes.js";
+export declare const tagName: 'open-dropdown';
+export declare class OpenDropdown extends OpenElement {
+  static override styles: [];
+  override render(): VNode;
+}
+export default OpenDropdown;

package/src/open-dropdown.js

@@ -0,0 +1,45 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-dropdown
+ *
+ * DaisyUI-style dropdown using DsdElement + Signals.
+ * State is reflected to the host `data-open` attribute.
+ * CSS uses `:host([data-open="true"])` to control visibility.
+ *
+ * Usage:
+ * ```html
+ * <open-dropdown>
+ *   <button slot="trigger">Open</button>
+ *   <div>Dropdown content</div>
+ * </open-dropdown>
+ * ```
+ *
+ * @slot trigger - Click target to toggle the dropdown
+ * @slot - Dropdown content (shown when open)
+ */ import { OpenElement } from '@openelement/element';
+import { signal } from '@openelement/signal';
+import { daisyClassSheet } from './daisy-classes.js';
+export const tagName = 'open-dropdown';
+export class OpenDropdown extends OpenElement {
+  static styles = [
+    daisyClassSheet
+  ];
+  #open = signal(false);
+  #toggle() {
+    this.#open.value = !this.#open.value;
+    this.setAttribute('data-open', String(this.#open.value));
+  }
+  render() {
+    return <div class='dropdown'>
+        <slot name='trigger' onClick={()=>this.#toggle()}/>
+        <div class='dropdown-content'>
+          <slot/>
+        </div>
+      </div>;
+  }
+}
+export default OpenDropdown;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenDropdown);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/open-hero-ping.d.ts

@@ -0,0 +1,27 @@
+/** @jsxImportSource @openelement/core */ /**
+ * Hero Ping - Ocean component (v0.20.0 Ocean-Island).
+ *
+ * Calls a real API endpoint and shows a status dot with response info.
+ * Pure DsdElement - zero Lit dependency. State changes are reflected
+ * by re-rendering the shadow DOM and re-hydrating events.
+ *
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart dot-static  - The static status dot
+ * @csspart dot-animated - The animated ping button
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-hero-ping';
+declare const styles: StyleSheetLike;
+export default class HeroPing extends OpenElement {
+  static override styles: [];
+  apiUrl: string;
+  _state: 'idle' | 'loading' | 'ok' | 'err';
+  _msg: string;
+  private _abortController?: any;
+  override connectedCallback(): void;
+  override disconnectedCallback(): void;
+  _fetch: () => Promise<void>;
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  private _renderToDom: any;
+}

package/src/open-hero-ping.js

@@ -0,0 +1,136 @@
+/** @jsxImportSource @openelement/core */ /**
+ * Hero Ping - Ocean component (v0.20.0 Ocean-Island).
+ *
+ * Calls a real API endpoint and shows a status dot with response info.
+ * Pure DsdElement - zero Lit dependency. State changes are reflected
+ * by re-rendering the shadow DOM and re-hydrating events.
+ *
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart dot-static  - The static status dot
+ * @csspart dot-animated - The animated ping button
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+export const tagName = 'open-hero-ping';
+const styles = new StyleSheet();
+styles.replaceSync(`
+  :host {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--size-2);
+  }
+  .ping {
+    padding: var(--size-1) var(--size-5);
+    border-radius: var(--radius-1);
+    border: var(--border-size-1) solid var(--gray-5);
+    background: transparent;
+    color: var(--gray-5);
+    font-size: var(--font-size-00);
+    cursor: pointer;
+    letter-spacing: var(--font-letterspacing-5);
+    text-transform: uppercase;
+    transition: all var(--ease-2) var(--duration-2);
+    font-family: inherit;
+    white-space: nowrap;
+  }
+  .ping:hover {
+    background: var(--gray-2);
+    color: var(--text-primary);
+    border-color: var(--gray-6);
+  }
+  .ping:disabled {
+    opacity: 0.3;
+    cursor: not-allowed;
+  }
+  .dot {
+    width: 7px;
+    height: 7px;
+    border-radius: var(--radius-round);
+    display: inline-block;
+    flex-shrink: 0;
+  }
+  .dot.idle { background: var(--gray-6); }
+  .dot.loading {
+    background: var(--gray-5);
+    animation: pulse 0.8s ease-in-out infinite alternate;
+  }
+  .dot.ok { background: var(--success); }
+  .dot.err { background: var(--error); }
+  .info {
+    font-family: var(--font-mono);
+    font-size: var(--font-size-00);
+    color: var(--text-muted);
+    white-space: nowrap;
+  }
+  .info .ok { color: var(--success); }
+  .info .err { color: var(--error); }
+  @keyframes pulse {
+    from { opacity: 0.4; }
+    to { opacity: 1; }
+  }
+`);
+export default class HeroPing extends OpenElement {
+  static styles = [
+    styles
+  ];
+  apiUrl = '';
+  _state = 'idle';
+  _msg = '';
+  _abortController;
+  connectedCallback() {
+    super.connectedCallback();
+    // DsdElement handles shadow root creation + initial render.
+    // Fetch after DOM is ready.
+    this._fetch();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._abortController?.abort();
+  }
+  _fetch = async ()=>{
+    this._abortController?.abort();
+    this._abortController = new AbortController();
+    this._state = 'loading';
+    this._msg = '';
+    this._renderToDom();
+    try {
+      const url = this.apiUrl || 'https://demo.openelement.org/api';
+      const r = await fetch(url, {
+        signal: this._abortController.signal
+      });
+      if (!r.ok) throw new Error(`HTTP ${r.status}`);
+      const d = await r.json();
+      this._state = 'ok';
+      this._msg = `${d.framework} v${d.version}  ${d.timestamp.slice(11, 19)}`;
+    } catch (e) {
+      if (e instanceof DOMException && e.name === 'AbortError') return;
+      const err = e;
+      this._state = 'err';
+      this._msg = String(e).includes('HTTP') ? err.message : 'connection failed';
+    } finally{
+      this._renderToDom();
+    }
+  };
+  render() {
+    const dotClass = `dot ${this._state}`;
+    const loading = this._state === 'loading';
+    return <>
+        <span className={dotClass} part='dot-static'></span>
+        <button type='button' className='ping' part='dot-animated' disabled={loading} onClick={this._fetch}>
+          {loading ? 'pinging...' : 'ping server'}
+        </button>
+        {this._msg && <span className='info'>
+            <span className={this._state}>{this._msg}</span>
+          </span>}
+      </>;
+  }
+  /** Re-render shadow DOM and re-hydrate click events. */ _renderToDom() {
+    if (!this.shadowRoot) return;
+    this.update();
+  }
+}
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, HeroPing);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/open-hero-ping.tsx"],"sourcesContent":["/** @jsxImportSource @openelement/core */\n/**\n * Hero Ping - Ocean component (v0.20.0 Ocean-Island).\n *\n * Calls a real API endpoint and shows a status dot with response info.\n * Pure DsdElement - zero Lit dependency. State changes are reflected\n * by re-rendering the shadow DOM and re-hydrating events.\n *\n * v0.24.1: Migrated from html`` template to JSX (ADR-0057).\n *\n * @csspart dot-static  - The static status dot\n * @csspart dot-animated - The animated ping button\n */\nimport { OpenElement } from '@openelement/element';\nimport { StyleSheet, type StyleSheetLike } from '@openelement/core/style-sheet';\nexport const tagName = 'open-hero-ping';\n\nconst styles: StyleSheetLike = new StyleSheet();\nstyles.replaceSync(`\n  :host {\n    display: inline-flex;\n    align-items: center;\n    gap: var(--size-2);\n  }\n  .ping {\n    padding: var(--size-1) var(--size-5);\n    border-radius: var(--radius-1);\n    border: var(--border-size-1) solid var(--gray-5);\n    background: transparent;\n    color: var(--gray-5);\n    font-size: var(--font-size-00);\n    cursor: pointer;\n    letter-spacing: var(--font-letterspacing-5);\n    text-transform: uppercase;\n    transition: all var(--ease-2) var(--duration-2);\n    font-family: inherit;\n    white-space: nowrap;\n  }\n  .ping:hover {\n    background: var(--gray-2);\n    color: var(--text-primary);\n    border-color: var(--gray-6);\n  }\n  .ping:disabled {\n    opacity: 0.3;\n    cursor: not-allowed;\n  }\n  .dot {\n    width: 7px;\n    height: 7px;\n    border-radius: var(--radius-round);\n    display: inline-block;\n    flex-shrink: 0;\n  }\n  .dot.idle { background: var(--gray-6); }\n  .dot.loading {\n    background: var(--gray-5);\n    animation: pulse 0.8s ease-in-out infinite alternate;\n  }\n  .dot.ok { background: var(--success); }\n  .dot.err { background: var(--error); }\n  .info {\n    font-family: var(--font-mono);\n    font-size: var(--font-size-00);\n    color: var(--text-muted);\n    white-space: nowrap;\n  }\n  .info .ok { color: var(--success); }\n  .info .err { color: var(--error); }\n  @keyframes pulse {\n    from { opacity: 0.4; }\n    to { opacity: 1; }\n  }\n`);\n\nexport default class HeroPing extends OpenElement {\n  static override styles = [styles];\n\n  apiUrl = '';\n  _state: 'idle' | 'loading' | 'ok' | 'err' = 'idle';\n  _msg = '';\n  private _abortController?: AbortController;\n\n  override connectedCallback(): void {\n    super.connectedCallback();\n    // DsdElement handles shadow root creation + initial render.\n    // Fetch after DOM is ready.\n    this._fetch();\n  }\n\n  override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._abortController?.abort();\n  }\n\n  _fetch = async (): Promise<void> => {\n    this._abortController?.abort();\n    this._abortController = new AbortController();\n    this._state = 'loading';\n    this._msg = '';\n    this._renderToDom();\n    try {\n      const url = this.apiUrl || 'https://demo.openelement.org/api';\n      const r = await fetch(url, { signal: this._abortController.signal });\n      if (!r.ok) throw new Error(`HTTP ${r.status}`);\n      const d = await r.json();\n      this._state = 'ok';\n      this._msg = `${d.framework} v${d.version}  ${d.timestamp.slice(11, 19)}`;\n    } catch (e: unknown) {\n      if (e instanceof DOMException && e.name === 'AbortError') return;\n      const err = e as Error;\n      this._state = 'err';\n      this._msg = String(e).includes('HTTP') ? err.message : 'connection failed';\n    } finally {\n      this._renderToDom();\n    }\n  };\n\n  override render(): ReturnType<typeof OpenElement.prototype.render> {\n    const dotClass = `dot ${this._state}`;\n    const loading = this._state === 'loading';\n    return (\n      <>\n        <span className={dotClass} part='dot-static'></span>\n        <button\n          type='button'\n          className='ping'\n          part='dot-animated'\n          disabled={loading}\n          onClick={this._fetch}\n        >\n          {loading ? 'pinging...' : 'ping server'}\n        </button>\n        {this._msg && (\n          <span className='info'>\n            <span className={this._state}>{this._msg}</span>\n          </span>\n        )}\n      </>\n    );\n  }\n\n  /** Re-render shadow DOM and re-hydrate click events. */\n  private _renderToDom(): void {\n    if (!this.shadowRoot) return;\n    this.update();\n  }\n}\n\n// Guard: idempotent across SSR paths\nif (typeof customElements !== 'undefined' && !customElements.get(tagName)) {\n  customElements.define(tagName, HeroPing);\n}\n"],"names":[],"mappings":"AAAA,uCAAuC,GACvC;;;;;;;;;;;CAWC,GACD,SAAS,WAAW,QAAQ,uBAAuB;AACnD,SAAS,UAAU,QAA6B,gCAAgC;AAChF,OAAO,MAAM,UAAU,iBAAiB;AAExC,MAAM,SAAyB,IAAI;AACnC,OAAO,WAAW,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDpB,CAAC;AAED,eAAe,MAAM,iBAAiB;EACpC,OAAgB,SAAS;IAAC;GAAO,CAAC;EAElC,SAAS,GAAG;EACZ,SAA4C,OAAO;EACnD,OAAO,GAAG;EACF,iBAAmC;EAElC,oBAA0B;IACjC,KAAK,CAAC;IACN,4DAA4D;IAC5D,4BAA4B;IAC5B,IAAI,CAAC,MAAM;EACb;EAES,uBAA6B;IACpC,KAAK,CAAC;IACN,IAAI,CAAC,gBAAgB,EAAE;EACzB;EAEA,SAAS;IACP,IAAI,CAAC,gBAAgB,EAAE;IACvB,IAAI,CAAC,gBAAgB,GAAG,IAAI;IAC5B,IAAI,CAAC,MAAM,GAAG;IACd,IAAI,CAAC,IAAI,GAAG;IACZ,IAAI,CAAC,YAAY;IACjB,IAAI;MACF,MAAM,MAAM,IAAI,CAAC,MAAM,IAAI;MAC3B,MAAM,IAAI,MAAM,MAAM,KAAK;QAAE,QAAQ,IAAI,CAAC,gBAAgB,CAAC,MAAM;MAAC;MAClE,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE;MAC7C,MAAM,IAAI,MAAM,EAAE,IAAI;MACtB,IAAI,CAAC,MAAM,GAAG;MACd,IAAI,CAAC,IAAI,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK;IAC1E,EAAE,OAAO,GAAY;MACnB,IAAI,aAAa,gBAAgB,EAAE,IAAI,KAAK,cAAc;MAC1D,MAAM,MAAM;MACZ,IAAI,CAAC,MAAM,GAAG;MACd,IAAI,CAAC,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAC,UAAU,IAAI,OAAO,GAAG;IACzD,SAAU;MACR,IAAI,CAAC,YAAY;IACnB;EACF,EAAE;EAEO,SAA0D;IACjE,MAAM,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE;IACrC,MAAM,UAAU,IAAI,CAAC,MAAM,KAAK;IAChC,SACI;QACA,CAAC,KAAK,WAAW,UAAU,KAAK,eAAe,KAAK;QACpD,CAAC,OACC,KAAK,SACL,UAAU,OACV,KAAK,eACL,UAAU,SACV,SAAS,IAAI,CAAC,MAAM,EACrB;UACC,CAAC,UAAU,eAAe,cAAc;QAC1C,EAAE,OAAO;QACT,CAAC,IAAI,CAAC,IAAI,KACP,KAAK,UAAU,OAAO;YACrB,CAAC,KAAK,WAAW,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,GAAG,KAAK;UAClD,EAAE,MACF;MACJ;EAEJ;EAEA,sDAAsD,GACtD,AAAQ,eAAqB;IAC3B,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;IACtB,IAAI,CAAC,MAAM;EACb;AACF;AAEA,qCAAqC;AACrC,IAAI,OAAO,mBAAmB,eAAe,CAAC,eAAe,GAAG,CAAC,UAAU;EACzE,eAAe,MAAM,CAAC,SAAS;AACjC"}

package/src/open-input.d.ts

@@ -0,0 +1,51 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-input
+ *
+ * Minimal input field following Swiss International Style.
+ * Clean borders, subtle focus states.
+ *
+ * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * Features:
+ * - Form-associated: participates in native <form> submission
+ * - Supports label, placeholder, error, disabled, required
+ * - Dispatches 'open-input' custom event on value change
+ *
+ * @csspart wrapper -The outer input-wrapper div
+ * @csspart label -The label element
+ * @csspart control -The input/textarea/select element
+ * @csspart error -The error message small element
+ *
+ * Usage:
+ * ```html
+ * <open-input placeholder="Enter text"></open-input>
+ * <open-input type="email" label="Email"></open-input>
+ * <form onsubmit="console.info(new FormData(this))">
+ *   <open-input name="username" label="Username"></open-input>
+ *   <button type="submit">Submit</button>
+ * </form>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-input';
+declare const sheet: StyleSheetLike;
+export declare class OpenInput extends OpenElement {
+  static override styles: [];
+  static formAssociated: boolean;
+  static delegatesFocus: boolean;
+  static override observedAttributes: [string, string, string, string, string, string, string, string];
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  override attributeChangedCallback(name: string, old: string | null, val: string | null): void;
+  private _syncDOM: any;
+  private _updateStates: any;
+  private _handleInput: any;
+  private _handleChange: any;
+  private _handleFocus: any;
+  private _handleBlur: any;
+  formResetCallback(): void;
+  formDisabledCallback(disabled: boolean): void;
+  private _esc: any;
+  private _escAttr: any;
+}
+export default OpenInput;