@openelement/ui 0.41.0-alpha.1

package/src/open-card.js

@@ -0,0 +1,107 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-card
+ *
+ * Minimal card container with optional header and footer.
+ * Swiss International Style: borders are whispers, not shouts.
+ *
+ * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart container - The article wrapper
+ * @csspart body - The card body content area
+ *
+ * Usage:
+ * ```html
+ * <open-card>
+ *   <h3 slot="header">Card Title</h3>
+ *   <p>Card content goes here.</p>
+ * </open-card>
+ *
+ * <open-card variant="elevated">
+ *   <p>Elevated card with shadow.</p>
+ * </open-card>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+export const tagName = 'open-card';
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: block;
+    background:
+      linear-gradient(135deg, color-mix(in srgb, var(--violet-1) 14%, transparent), transparent 48%),
+      var(--bg-card);
+    color: var(--text-primary);
+    border: var(--border-size-1) solid var(--border);
+    border-radius: var(--card-radius);
+    overflow: hidden;
+    transition: border-color var(--ease-3) var(--duration-2), background var(--ease-3) var(--duration-2), box-shadow var(--ease-3) var(--duration-2);
+  }
+
+  :host([variant="elevated"]) {
+    box-shadow: 0 var(--size-2) var(--size-8) color-mix(in srgb, var(--brand) 8%, transparent);
+    border-color: var(--border);
+  }
+
+  :host([variant="elevated"]:hover) {
+    border-color: var(--brand);
+  }
+
+  :host([variant="borderless"]) {
+    border-color: transparent;
+  }
+
+  :host([variant="muted"]) {
+    background: var(--bg-surface);
+  }
+
+  :host([variant="artifact"]) {
+    background: var(--bg-code, var(--gray-11));
+    color: var(--gray-2);
+    border-color: var(--code-border, var(--gray-8));
+  }
+
+  ::slotted([slot="header"]) {
+    padding: var(--size-4) var(--size-5);
+    border-bottom: var(--border-size-1) solid var(--border);
+    font-size: var(--font-size-2);
+    font-weight: var(--font-weight-6);
+    color: var(--text-primary);
+    margin: 0;
+  }
+
+  .card-body {
+    padding: var(--size-5);
+  }
+
+  ::slotted([slot="footer"]) {
+    padding: var(--size-3) var(--size-5);
+    border-top: var(--border-size-1) solid var(--border);
+    font-size: var(--font-size-0);
+    color: var(--text-muted);
+    margin: 0;
+  }
+`);
+export class OpenCard extends OpenElement {
+  static styles = [
+    sheet
+  ];
+  static observedAttributes = [
+    'variant'
+  ];
+  render() {
+    return <article part='container'>
+        <slot name='header'></slot>
+        <div className='card-body' part='body'>
+          <slot></slot>
+        </div>
+        <slot name='footer'></slot>
+      </article>;
+  }
+}
+export default OpenCard;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenCard);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/open-code-block.d.ts

@@ -0,0 +1,44 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-code-block
+ *
+ * Code block with copy button AND syntax highlighting via Prism.
+ *
+ * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).
+ *   - Self-contained Prism highlighting injected into shadow root
+ *   - Copy button uses ElementInternals :state(copied) for CSS feedback
+ *   - DSD renders <slot> for SSR (no JS content fallback)
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart copy - The copy button
+ *
+ * Usage:
+ * ```html
+ * <open-code-block>
+ *   <pre><code>const x = 1;</code></pre>
+ * </open-code-block>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-code-block';
+declare const sheet: StyleSheetLike;
+export declare class OpenCodeBlock extends OpenElement {
+  static override styles: [];
+  private _copyState: any;
+  private _copyTimer: any;
+  private _highlightTimer: any;
+  private _highlightedInShadow: any;
+  private _highlightRetries: any;
+  private static MAX_HIGHLIGHT_RETRIES: any;
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  override connectedCallback(): void;
+  override onDsdHydrated(): void;
+  override onCsrRendered(): void;
+  override disconnectedCallback(): void;
+  private _prismGlobal: any;
+  private _tryHighlight: any;
+  private _injectHighlighted: any;
+  private _getCodeText: any;
+  private _copy: any;
+  private _updateCopyButtonDOM: any;
+}
+export default OpenCodeBlock;

package/src/open-code-block.js

@@ -0,0 +1,267 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-code-block
+ *
+ * Code block with copy button AND syntax highlighting via Prism.
+ *
+ * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).
+ *   - Self-contained Prism highlighting injected into shadow root
+ *   - Copy button uses ElementInternals :state(copied) for CSS feedback
+ *   - DSD renders <slot> for SSR (no JS content fallback)
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart copy - The copy button
+ *
+ * Usage:
+ * ```html
+ * <open-code-block>
+ *   <pre><code>const x = 1;</code></pre>
+ * </open-code-block>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+import { createLogger } from '@openelement/core/logger';
+export const tagName = 'open-code-block';
+const log = createLogger('ui');
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: block;
+    position: relative;
+  }
+
+  pre {
+    margin: 0;
+    padding: var(--size-5);
+    background: var(--bg-code);
+    border: var(--border-size-1) solid var(--code-border);
+    border-radius: var(--radius-3);
+    overflow-x: auto;
+    font-family: var(--font-mono);
+    font-size: var(--font-size-0);
+    line-height: var(--font-lineheight-4);
+    color: var(--text-secondary);
+    scrollbar-width: thin;
+    scrollbar-color: var(--brand-subtle) transparent;
+    white-space: pre-wrap;
+    word-break: break-word;
+  }
+
+  ::slotted(pre) {
+    margin: 0;
+    padding: var(--size-5);
+    background: var(--bg-code);
+    border: var(--border-size-1) solid var(--code-border);
+    border-radius: var(--radius-3);
+    overflow-x: auto;
+    font-family: var(--font-mono);
+    font-size: var(--font-size-0);
+    line-height: var(--font-lineheight-4);
+    color: var(--text-secondary);
+    scrollbar-width: thin;
+    scrollbar-color: var(--brand-subtle) transparent;
+  }
+
+  .lang-badge {
+    position: absolute;
+    top: var(--size-2);
+    left: var(--size-3);
+    font-size: var(--font-size-00);
+    font-weight: var(--font-weight-7);
+    text-transform: uppercase;
+    letter-spacing: var(--font-letterspacing-5);
+    color: var(--text-muted);
+    pointer-events: none;
+  }
+
+  .copy-btn {
+    position: absolute;
+    top: var(--size-2);
+    right: var(--size-2);
+    background: var(--brand-subtle);
+    color: var(--text-muted);
+    padding: var(--size-1) var(--size-3);
+    font-size: var(--font-size-00);
+    font-family: var(--font-sans);
+    font-weight: var(--font-weight-6);
+    border: 0.5px solid transparent;
+    cursor: pointer;
+    border-radius: var(--radius-1);
+    transition: all var(--ease-2) var(--duration-2);
+    z-index: 1;
+    letter-spacing: var(--font-letterspacing-4);
+  }
+
+  .copy-btn:hover {
+    color: var(--text-primary);
+    background: var(--brand-glow);
+    border-color: var(--brand);
+  }
+
+  :host(:state(copied)) .copy-btn {
+    color: #22c55e;
+    border-color: rgba(34,197,94,0.3);
+    background: rgba(34,197,94,0.08);
+  }
+
+  :host(:state(failed)) .copy-btn {
+    color: var(--error);
+    border-color: var(--error);
+  }
+
+  /* Prism token colors (dark theme) */
+  .token.cdata, .token.comment, .token.doctype, .token.prolog { color: #6a737d; }
+  .token.punctuation { color: #8b949e; }
+  .token.namespace { opacity: 0.7; }
+  .token.boolean, .token.constant, .token.deleted, .token.number, .token.property, .token.symbol, .token.tag { color: #79c0ff; }
+  .token.attr-name, .token.builtin, .token.char, .token.inserted, .token.selector, .token.string { color: #a5d6ff; }
+  .token.entity, .token.operator, .token.url, .language-css .token.string, .style .token.string { color: #d2a8ff; }
+  .token.atrule, .token.attr-value, .token.keyword { color: #ff7b72; }
+  .token.class-name, .token.function { color: #d2a8ff; }
+  .token.important, .token.regex, .token.variable { color: #ffa657; }
+  .token.bold, .token.important { font-weight: 700; }
+  .token.italic { font-style: italic; }
+  .token.entity { cursor: help; }
+`);
+export class OpenCodeBlock extends OpenElement {
+  static styles = [
+    sheet
+  ];
+  _copyState = 'idle';
+  _copyTimer;
+  _highlightTimer;
+  _highlightedInShadow = false;
+  _highlightRetries = 0;
+  static MAX_HIGHLIGHT_RETRIES = 120;
+  render() {
+    return <>
+        <slot></slot>
+        <button type='button' className='copy-btn' part='copy' onClick={()=>this._copy()}>
+          Copy
+        </button>
+      </>;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+  }
+  onDsdHydrated() {
+    super.onDsdHydrated();
+    this._tryHighlight();
+  }
+  onCsrRendered() {
+    super.onCsrRendered();
+    this._tryHighlight();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    if (this._copyTimer !== undefined) {
+      clearTimeout(this._copyTimer);
+      this._copyTimer = undefined;
+    }
+    if (this._highlightTimer !== undefined) {
+      clearTimeout(this._highlightTimer);
+      this._highlightTimer = undefined;
+    }
+  }
+  _prismGlobal() {
+    return globalThis.Prism;
+  }
+  _tryHighlight() {
+    const p = this._prismGlobal();
+    if (typeof p === 'undefined') {
+      if (this._highlightRetries++ < OpenCodeBlock.MAX_HIGHLIGHT_RETRIES) {
+        // Exponential backoff: 10, 20, 40, 80, 160, 320, 500ms cap
+        const delay = Math.min(10 * Math.pow(2, Math.min(this._highlightRetries, 6)), 500);
+        this._highlightTimer = globalThis.setTimeout(()=>this._tryHighlight(), delay);
+      }
+      return;
+    }
+    const pre = this.querySelector(':scope > pre') || Array.from(this.children).find((c)=>c.tagName === 'PRE');
+    if (!pre) return;
+    const codeEl = pre.querySelector('code');
+    if (!codeEl) return;
+    let lang = 'typescript';
+    const classes = codeEl.classList;
+    for(let i = 0; i < classes.length; i++){
+      if (classes[i].startsWith('language-')) {
+        lang = classes[i].slice(9);
+        break;
+      }
+    }
+    const raw = codeEl.textContent || '';
+    const grammar = p.languages?.[lang];
+    if (!grammar) {
+      if (this._highlightRetries++ < OpenCodeBlock.MAX_HIGHLIGHT_RETRIES) {
+        const delay = Math.min(20 * Math.pow(2, Math.min(this._highlightRetries, 6)), 1000);
+        this._highlightTimer = globalThis.setTimeout(()=>this._tryHighlight(), delay);
+      }
+      return;
+    }
+    this._highlightRetries = 0;
+    const highlightedHtml = p.highlight(raw, grammar, lang);
+    this._injectHighlighted(highlightedHtml);
+  }
+  _injectHighlighted(html) {
+    if (!this.shadowRoot || this._highlightedInShadow) return;
+    this._highlightedInShadow = true;
+    const slot1 = this.shadowRoot.querySelector('slot');
+    if (!slot1) return;
+    const highlightedPre = document.createElement('pre');
+    const highlightedCode = document.createElement('code');
+    highlightedCode.className = 'language-typescript';
+    highlightedCode.innerHTML = html;
+    highlightedPre.appendChild(highlightedCode);
+    slot1.replaceWith(highlightedPre);
+    const lightPre = this.querySelector('pre');
+    if (lightPre) lightPre.style.display = 'none';
+  }
+  _getCodeText() {
+    if (this.shadowRoot) {
+      const shadowCode = this.shadowRoot.querySelector('pre code');
+      if (shadowCode) return shadowCode.textContent || '';
+    }
+    return this.textContent || '';
+  }
+  async _copy() {
+    try {
+      const text = this._getCodeText();
+      await navigator.clipboard.writeText(text);
+      this._copyState = 'copied';
+      this._internals?.states.add('copied');
+      this._internals?.states.delete('failed');
+      this._updateCopyButtonDOM();
+      this._copyTimer = globalThis.setTimeout(()=>{
+        this._copyState = 'idle';
+        this._internals?.states.delete('copied');
+        this._updateCopyButtonDOM();
+        this._copyTimer = undefined;
+      }, 2000);
+    } catch (e) {
+      log.warn('Clipboard write failed:', e);
+      this._internals?.states.add('failed');
+      this._internals?.states.delete('copied');
+      this._updateCopyButtonDOM();
+      this._copyTimer = globalThis.setTimeout(()=>{
+        this._copyState = 'idle';
+        this._internals?.states.delete('failed');
+        this._updateCopyButtonDOM();
+        this._copyTimer = undefined;
+      }, 2000);
+    }
+  }
+  _updateCopyButtonDOM() {
+    if (!this.shadowRoot) return;
+    const btn = this.shadowRoot.querySelector('button.copy-btn');
+    if (!btn) return;
+    btn.classList.toggle('copied', this._copyState === 'copied');
+    btn.classList.toggle('failed', this._copyState === 'failed');
+    if (this._copyState === 'copied') btn.textContent = 'Copied!';
+    else if (this._copyState === 'failed') btn.textContent = 'Failed';
+    else btn.textContent = 'Copy';
+  }
+}
+export default OpenCodeBlock;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenCodeBlock);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/open-code-block.tsx"],"sourcesContent":["/** @jsxImportSource @openelement/core */\n/**\n * @openelement/ui - open-code-block\n *\n * Code block with copy button AND syntax highlighting via Prism.\n *\n * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).\n *   - Self-contained Prism highlighting injected into shadow root\n *   - Copy button uses ElementInternals :state(copied) for CSS feedback\n *   - DSD renders <slot> for SSR (no JS content fallback)\n * v0.24.1: Migrated from html`` template to JSX (ADR-0057).\n *\n * @csspart copy - The copy button\n *\n * Usage:\n * ```html\n * <open-code-block>\n *   <pre><code>const x = 1;</code></pre>\n * </open-code-block>\n * ```\n */\n\nimport { OpenElement } from '@openelement/element';\nimport { StyleSheet, type StyleSheetLike } from '@openelement/core/style-sheet';\nimport { createLogger } from '@openelement/core/logger';\nexport const tagName = 'open-code-block';\n\nconst log = createLogger('ui');\n\nconst sheet: StyleSheetLike = new StyleSheet();\nsheet.replaceSync(`\n  :host {\n    display: block;\n    position: relative;\n  }\n\n  pre {\n    margin: 0;\n    padding: var(--size-5);\n    background: var(--bg-code);\n    border: var(--border-size-1) solid var(--code-border);\n    border-radius: var(--radius-3);\n    overflow-x: auto;\n    font-family: var(--font-mono);\n    font-size: var(--font-size-0);\n    line-height: var(--font-lineheight-4);\n    color: var(--text-secondary);\n    scrollbar-width: thin;\n    scrollbar-color: var(--brand-subtle) transparent;\n    white-space: pre-wrap;\n    word-break: break-word;\n  }\n\n  ::slotted(pre) {\n    margin: 0;\n    padding: var(--size-5);\n    background: var(--bg-code);\n    border: var(--border-size-1) solid var(--code-border);\n    border-radius: var(--radius-3);\n    overflow-x: auto;\n    font-family: var(--font-mono);\n    font-size: var(--font-size-0);\n    line-height: var(--font-lineheight-4);\n    color: var(--text-secondary);\n    scrollbar-width: thin;\n    scrollbar-color: var(--brand-subtle) transparent;\n  }\n\n  .lang-badge {\n    position: absolute;\n    top: var(--size-2);\n    left: var(--size-3);\n    font-size: var(--font-size-00);\n    font-weight: var(--font-weight-7);\n    text-transform: uppercase;\n    letter-spacing: var(--font-letterspacing-5);\n    color: var(--text-muted);\n    pointer-events: none;\n  }\n\n  .copy-btn {\n    position: absolute;\n    top: var(--size-2);\n    right: var(--size-2);\n    background: var(--brand-subtle);\n    color: var(--text-muted);\n    padding: var(--size-1) var(--size-3);\n    font-size: var(--font-size-00);\n    font-family: var(--font-sans);\n    font-weight: var(--font-weight-6);\n    border: 0.5px solid transparent;\n    cursor: pointer;\n    border-radius: var(--radius-1);\n    transition: all var(--ease-2) var(--duration-2);\n    z-index: 1;\n    letter-spacing: var(--font-letterspacing-4);\n  }\n\n  .copy-btn:hover {\n    color: var(--text-primary);\n    background: var(--brand-glow);\n    border-color: var(--brand);\n  }\n\n  :host(:state(copied)) .copy-btn {\n    color: #22c55e;\n    border-color: rgba(34,197,94,0.3);\n    background: rgba(34,197,94,0.08);\n  }\n\n  :host(:state(failed)) .copy-btn {\n    color: var(--error);\n    border-color: var(--error);\n  }\n\n  /* Prism token colors (dark theme) */\n  .token.cdata, .token.comment, .token.doctype, .token.prolog { color: #6a737d; }\n  .token.punctuation { color: #8b949e; }\n  .token.namespace { opacity: 0.7; }\n  .token.boolean, .token.constant, .token.deleted, .token.number, .token.property, .token.symbol, .token.tag { color: #79c0ff; }\n  .token.attr-name, .token.builtin, .token.char, .token.inserted, .token.selector, .token.string { color: #a5d6ff; }\n  .token.entity, .token.operator, .token.url, .language-css .token.string, .style .token.string { color: #d2a8ff; }\n  .token.atrule, .token.attr-value, .token.keyword { color: #ff7b72; }\n  .token.class-name, .token.function { color: #d2a8ff; }\n  .token.important, .token.regex, .token.variable { color: #ffa657; }\n  .token.bold, .token.important { font-weight: 700; }\n  .token.italic { font-style: italic; }\n  .token.entity { cursor: help; }\n`);\n\nexport class OpenCodeBlock extends OpenElement {\n  static override styles = [sheet];\n\n  private _copyState: 'idle' | 'copied' | 'failed' = 'idle';\n  private _copyTimer: ReturnType<typeof setTimeout> | undefined;\n  private _highlightTimer: ReturnType<typeof setTimeout> | undefined;\n  private _highlightedInShadow = false;\n  private _highlightRetries = 0;\n  private static MAX_HIGHLIGHT_RETRIES = 120;\n\n  override render(): ReturnType<typeof OpenElement.prototype.render> {\n    return (\n      <>\n        <slot></slot>\n        <button type='button' className='copy-btn' part='copy' onClick={() => this._copy()}>\n          Copy\n        </button>\n      </>\n    );\n  }\n\n  override connectedCallback(): void {\n    super.connectedCallback();\n  }\n\n  override onDsdHydrated(): void {\n    super.onDsdHydrated();\n    this._tryHighlight();\n  }\n\n  override onCsrRendered(): void {\n    super.onCsrRendered();\n    this._tryHighlight();\n  }\n\n  override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    if (this._copyTimer !== undefined) {\n      clearTimeout(this._copyTimer);\n      this._copyTimer = undefined;\n    }\n    if (this._highlightTimer !== undefined) {\n      clearTimeout(this._highlightTimer);\n      this._highlightTimer = undefined;\n    }\n  }\n\n  private _prismGlobal(): unknown {\n    return (globalThis as typeof globalThis & { Prism?: unknown }).Prism;\n  }\n\n  private _tryHighlight(): void {\n    const p = this._prismGlobal();\n    if (typeof p === 'undefined') {\n      if (this._highlightRetries++ < OpenCodeBlock.MAX_HIGHLIGHT_RETRIES) {\n        // Exponential backoff: 10, 20, 40, 80, 160, 320, 500ms cap\n        const delay = Math.min(10 * Math.pow(2, Math.min(this._highlightRetries, 6)), 500);\n        this._highlightTimer = globalThis.setTimeout(() => this._tryHighlight(), delay);\n      }\n      return;\n    }\n\n    const pre = this.querySelector(':scope > pre') ||\n      Array.from(this.children).find((c) => c.tagName === 'PRE');\n    if (!pre) return;\n    const codeEl = pre.querySelector('code');\n    if (!codeEl) return;\n\n    let lang = 'typescript';\n    const classes = codeEl.classList;\n    for (let i = 0; i < classes.length; i++) {\n      if (classes[i].startsWith('language-')) {\n        lang = classes[i].slice(9);\n        break;\n      }\n    }\n\n    const raw = codeEl.textContent || '';\n    const grammar = (p as Record<string, Record<string, unknown>>).languages?.[lang] as\n      | Record<string, unknown>\n      | undefined;\n    if (!grammar) {\n      if (this._highlightRetries++ < OpenCodeBlock.MAX_HIGHLIGHT_RETRIES) {\n        const delay = Math.min(20 * Math.pow(2, Math.min(this._highlightRetries, 6)), 1000);\n        this._highlightTimer = globalThis.setTimeout(() => this._tryHighlight(), delay);\n      }\n      return;\n    }\n    this._highlightRetries = 0;\n    const highlightedHtml =\n      (p as { highlight: (code: string, grammar: unknown, lang: string) => string }).highlight(\n        raw,\n        grammar,\n        lang,\n      );\n    this._injectHighlighted(highlightedHtml);\n  }\n\n  private _injectHighlighted(html: string): void {\n    if (!this.shadowRoot || this._highlightedInShadow) return;\n    this._highlightedInShadow = true;\n\n    const slot = this.shadowRoot.querySelector('slot');\n    if (!slot) return;\n\n    const highlightedPre = document.createElement('pre');\n    const highlightedCode = document.createElement('code');\n    highlightedCode.className = 'language-typescript';\n    highlightedCode.innerHTML = html;\n    highlightedPre.appendChild(highlightedCode);\n    slot.replaceWith(highlightedPre);\n\n    const lightPre = this.querySelector('pre');\n    if (lightPre) (lightPre as HTMLElement).style.display = 'none';\n  }\n\n  private _getCodeText(): string {\n    if (this.shadowRoot) {\n      const shadowCode = this.shadowRoot.querySelector('pre code');\n      if (shadowCode) return shadowCode.textContent || '';\n    }\n    return this.textContent || '';\n  }\n\n  private async _copy(): Promise<void> {\n    try {\n      const text = this._getCodeText();\n      await navigator.clipboard.writeText(text);\n      this._copyState = 'copied';\n      this._internals?.states.add('copied');\n      this._internals?.states.delete('failed');\n      this._updateCopyButtonDOM();\n      this._copyTimer = globalThis.setTimeout(() => {\n        this._copyState = 'idle';\n        this._internals?.states.delete('copied');\n        this._updateCopyButtonDOM();\n        this._copyTimer = undefined;\n      }, 2000);\n    } catch (e) {\n      log.warn('Clipboard write failed:', e);\n      this._internals?.states.add('failed');\n      this._internals?.states.delete('copied');\n      this._updateCopyButtonDOM();\n      this._copyTimer = globalThis.setTimeout(() => {\n        this._copyState = 'idle';\n        this._internals?.states.delete('failed');\n        this._updateCopyButtonDOM();\n        this._copyTimer = undefined;\n      }, 2000);\n    }\n  }\n\n  private _updateCopyButtonDOM(): void {\n    if (!this.shadowRoot) return;\n    const btn = this.shadowRoot.querySelector('button.copy-btn');\n    if (!btn) return;\n    btn.classList.toggle('copied', this._copyState === 'copied');\n    btn.classList.toggle('failed', this._copyState === 'failed');\n    if (this._copyState === 'copied') btn.textContent = 'Copied!';\n    else if (this._copyState === 'failed') btn.textContent = 'Failed';\n    else btn.textContent = 'Copy';\n  }\n}\n\nexport default OpenCodeBlock;\n\n// Guard: idempotent across SSR paths\nif (typeof customElements !== 'undefined' && !customElements.get(tagName)) {\n  customElements.define(tagName, OpenCodeBlock);\n}\n"],"names":[],"mappings":"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"}

package/src/open-dialog.d.ts

@@ -0,0 +1,47 @@
+/** @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 { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-dialog';
+declare const sheet: StyleSheetLike;
+export declare class OpenDialog extends OpenElement {
+  static override styles: [];
+  static delegatesFocus: boolean;
+  static override observedAttributes: [string, string];
+  private static _originalInertStates: any;
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  override attributeChangedCallback(name: string, old: string | null, val: string | null): void;
+  private _updateStates: any;
+  show(): void;
+  close(): void;
+  toggle(): void;
+  private _syncDialogElement: any;
+  private _syncInert: any;
+  override disconnectedCallback(): void;
+  private _handleClose: any;
+  private _handleCancel: any;
+  private _handleTrigger: any;
+  private _esc: any;
+  private _escAttr: any;
+}
+export default OpenDialog;