@openelement/ui 0.41.0-alpha.1

package/src/open-tabs.js

@@ -0,0 +1,56 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-tabs
+ *
+ * DaisyUI-style tabs using DsdElement + Signals.
+ * Reads light DOM children with `slot="tab"` and `slot="panel"`
+ * to render tab buttons and panel content.
+ *
+ * Usage:
+ * ```html
+ * <open-tabs>
+ *   <span slot="tab">Tab 1</span>
+ *   <span slot="tab">Tab 2</span>
+ *   <div slot="panel">Panel 1 content</div>
+ *   <div slot="panel">Panel 2 content</div>
+ * </open-tabs>
+ * ```
+ *
+ * @slot tab - Tab button labels (multiple)
+ * @slot panel - Tab panel content (multiple, one per tab)
+ */ import { OpenElement } from '@openelement/element';
+import { signal } from '@openelement/signal';
+import { daisyClassSheet } from './daisy-classes.js';
+export const tagName = 'open-tabs';
+export class OpenTabs extends OpenElement {
+  static styles = [
+    daisyClassSheet
+  ];
+  #active = signal(0);
+  #select(idx) {
+    this.#active.value = idx;
+    this.update();
+  }
+  render() {
+    const tabs = this.querySelectorAll('[slot="tab"]');
+    const panels = this.querySelectorAll('[slot="panel"]');
+    const active = this.#active.value;
+    return <div>
+        <div class='tabs'>
+          {Array.from(tabs).map((tab, i)=><button type='button' class={`tab ${i === active ? 'tab-active' : ''}`} onClick={()=>this.#select(i)}>
+              {tab.textContent}
+            </button>)}
+        </div>
+        <div>
+          {Array.from(panels).map((panel, i)=><div style={{
+        display: i === active ? 'block' : 'none'
+      }}>{panel.innerHTML}</div>)}
+        </div>
+      </div>;
+  }
+}
+export default OpenTabs;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenTabs);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/open-theme-toggle.d.ts

@@ -0,0 +1,38 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-theme-toggle
+ *
+ * Theme toggle Reactive DSD component for Dark/Light mode switching.
+ * Swiss International Style: Pure B&W, minimal.
+ *
+ * v0.21.0: Uses DsdElement + html templates + Signals.
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart toggle -The button element
+ * @csspart icon-sun -The sun SVG icon
+ * @csspart icon-moon -The moon SVG icon
+ *
+ * Usage:
+ * ```html
+ * <open-theme-toggle theme="light"></open-theme-toggle>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-theme-toggle';
+declare const sheet: StyleSheetLike;
+export declare class OpenThemeToggle extends OpenElement {
+  static override styles: [];
+  static delegatesFocus: boolean;
+  static override observedAttributes: [string];
+  private _theme: any;
+  private _initDone: any;
+  override connectedCallback(): void;
+  private _initTheme: any;
+  private _persistTheme: any;
+  protected override onDsdHydrated(): void;
+  protected override onCsrRendered(): void;
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  private _handleToggle: any;
+  private _dispatchThemeChange: any;
+  override attributeChangedCallback(name: string, old: string | null, val: string | null): void;
+}
+export default OpenThemeToggle;

package/src/open-theme-toggle.js

@@ -0,0 +1,223 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-theme-toggle
+ *
+ * Theme toggle Reactive DSD component for Dark/Light mode switching.
+ * Swiss International Style: Pure B&W, minimal.
+ *
+ * v0.21.0: Uses DsdElement + html templates + Signals.
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart toggle -The button element
+ * @csspart icon-sun -The sun SVG icon
+ * @csspart icon-moon -The moon SVG icon
+ *
+ * Usage:
+ * ```html
+ * <open-theme-toggle theme="light"></open-theme-toggle>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+import { signal } from '@openelement/signal';
+export const tagName = 'open-theme-toggle';
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: inline-block;
+  }
+
+  .theme-toggle {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 38px; height: 38px; padding: 0;
+    border: var(--border-size-1) solid color-mix(in srgb, var(--border) 72%, var(--brand));
+    border-radius: var(--radius-round);
+    background: color-mix(in srgb, var(--bg-elevated) 76%, transparent);
+    color: var(--text-muted);
+    box-shadow: inset 0 1px 0 color-mix(in srgb, var(--gray-0) 70%, transparent);
+    cursor: pointer;
+    transition: all var(--ease-2) var(--duration-2);
+  }
+  .theme-toggle:hover {
+    color: var(--text-primary);
+    border-color: var(--brand-light);
+    background: color-mix(in srgb, var(--brand-pale) 42%, var(--bg-elevated));
+  }
+
+  .theme-toggle svg {
+    width: 16px;
+    height: 16px;
+  }
+
+  .theme-toggle .icon-sun {
+    display: block;
+  }
+
+  .theme-toggle .icon-moon {
+    display: none;
+  }
+
+  .theme-toggle[data-theme="light"] .icon-sun {
+    display: none;
+  }
+
+  .theme-toggle[data-theme="light"] .icon-moon {
+    display: block;
+  }
+`);
+export class OpenThemeToggle extends OpenElement {
+  // ponytail: Safari does not recompute adoptedStyleSheets when
+  // :host([data-theme]) changes. The token sheets (openPropsTokenSheet,
+  // daisyClassSheet) are already injected as page-level <style> by
+  // vite.config.ts — CSS custom properties cascade from :root naturally.
+  // Only adopt the component-specific sheet.
+  static styles = [
+    sheet
+  ];
+  static delegatesFocus = true;
+  static observedAttributes = [
+    'theme'
+  ];
+  _theme = signal('dark');
+  _initDone = false;
+  connectedCallback() {
+    super.connectedCallback();
+    requestAnimationFrame(()=>this._initTheme());
+  }
+  /**
+   * v0.23.0: Theme initialization lives in _initTheme(), called from
+   * both onDsdHydrated() and onCsrRendered() so that the priority
+   * chain works regardless of hydration path.
+   *
+   * Priority: theme attribute > document.documentElement.dataset.theme
+   * > localStorage > prefers-color-scheme > default 'dark'.
+   */ _initTheme() {
+    if (this._initDone) return;
+    this._initDone = true;
+    const themeAttr = this.getAttribute('theme');
+    if (themeAttr === 'light') {
+      this._theme.value = 'light';
+    } else if (themeAttr === 'dark') {
+      this._theme.value = 'dark';
+    } else {
+      const docTheme = document.documentElement?.dataset?.theme;
+      if (docTheme === 'light') {
+        this._theme.value = 'light';
+      } else if (docTheme === 'dark') {
+        this._theme.value = 'dark';
+      } else {
+        let resolved = false;
+        try {
+          const saved = localStorage.getItem('open-theme');
+          if (saved === 'light') {
+            this._theme.value = 'light';
+            resolved = true;
+          } else if (saved === 'dark') {
+            this._theme.value = 'dark';
+            resolved = true;
+          }
+        } catch  {}
+        if (!resolved && globalThis.matchMedia) {
+          this._theme.value = globalThis.matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark';
+        }
+      }
+    }
+    this.setAttribute('data-theme', this._theme.value);
+    document.documentElement.setAttribute('data-theme', this._theme.value);
+    if (document.documentElement.style) {
+      document.documentElement.style.colorScheme = this._theme.value;
+    }
+    // Propagate to parent open-layout
+    try {
+      const root = this.getRootNode();
+      if (root instanceof ShadowRoot && root.host) {
+        root.host.setAttribute('data-theme', this._theme.value);
+      }
+    } catch  {}
+    this._dispatchThemeChange(this._theme.value);
+    this._persistTheme(this._theme.value);
+  }
+  _persistTheme(theme) {
+    try {
+      localStorage.setItem('open-theme', theme);
+    } catch  {}
+  }
+  onDsdHydrated() {
+    super.onDsdHydrated();
+    requestAnimationFrame(()=>this._initTheme());
+  }
+  onCsrRendered() {
+    super.onCsrRendered();
+  }
+  render() {
+    // Zero signal.value reads in render (ADR-0062).
+    // effect binding that updates the attribute when theme changes.
+    // CSS selectors ([data-theme="light"]) handle icon visibility.
+    return <button type='button' className='theme-toggle' part='toggle' data-theme={this._theme} aria-label='Toggle theme' onClick={()=>this._handleToggle()}>
+        <svg className='icon-sun' part='icon-sun' viewBox='0 0 16 16' fill='none' stroke='currentColor' stroke-width='1.2' stroke-linecap='round'>
+          <circle cx='8' cy='8' r='3'/>
+          <line x1='8' y1='1' x2='8' y2='3'/>
+          <line x1='8' y1='13' x2='8' y2='15'/>
+          <line x1='1' y1='8' x2='3' y2='8'/>
+          <line x1='13' y1='8' x2='15' y2='8'/>
+          <line x1='3.05' y1='3.05' x2='4.46' y2='4.46'/>
+          <line x1='11.54' y1='11.54' x2='12.95' y2='12.95'/>
+          <line x1='3.05' y1='12.95' x2='4.46' y2='11.54'/>
+          <line x1='11.54' y1='4.46' x2='12.95' y2='3.05'/>
+        </svg>
+        <svg className='icon-moon' part='icon-moon' viewBox='0 0 16 16' fill='none' stroke='currentColor' stroke-width='1.2' stroke-linecap='round'>
+          <path d='M13.5 9.14A5.5 5.5 0 0 1 6.86 2.5 5.5 5.5 0 1 0 13.5 9.14Z'/>
+        </svg>
+      </button>;
+  }
+  _handleToggle() {
+    const theme = this._theme.value === 'light' ? 'dark' : 'light';
+    this._theme.value = theme;
+    document.documentElement.setAttribute('data-theme', theme);
+    if (document.documentElement.style) {
+      document.documentElement.style.colorScheme = theme;
+    }
+    // Propagate data-theme to parent <open-layout> so :host([data-theme="dark"]) matches
+    try {
+      const root = this.getRootNode();
+      if (root instanceof ShadowRoot && root.host) {
+        root.host.setAttribute('data-theme', theme);
+      }
+    } catch (e) {
+      console.debug('[open-theme-toggle] getRootNode unavailable:', e);
+    }
+    this._dispatchThemeChange(theme);
+    try {
+      localStorage.setItem('open-theme', theme);
+    } catch (e) {
+      console.debug('[open-theme-toggle] localStorage.setItem unavailable:', e);
+    }
+  // data-theme attribute is managed by signal prop binding (data-theme={this._theme})
+  }
+  _dispatchThemeChange(theme) {
+    try {
+      if (typeof CustomEvent !== 'undefined' && typeof globalThis.dispatchEvent === 'function') {
+        globalThis.dispatchEvent(new CustomEvent('open:theme-change', {
+          detail: {
+            theme
+          }
+        }));
+      }
+    } catch (e) {
+      console.debug('[open-theme-toggle] theme event dispatch unavailable:', e);
+    }
+  }
+  attributeChangedCallback(name, old, val) {
+    if (old === val) return;
+    if (name === 'theme' && val) {
+      this._theme.value = val === 'light' ? 'light' : 'dark';
+      this.setAttribute('data-theme', this._theme.value);
+    }
+  }
+}
+export default OpenThemeToggle;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenThemeToggle);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/open-theme-toggle.tsx"],"sourcesContent":["/** @jsxImportSource @openelement/core */\n/**\n * @openelement/ui - open-theme-toggle\n *\n * Theme toggle Reactive DSD component for Dark/Light mode switching.\n * Swiss International Style: Pure B&W, minimal.\n *\n * v0.21.0: Uses DsdElement + html templates + Signals.\n * v0.24.1: Migrated from html`` template to JSX (ADR-0057).\n *\n * @csspart toggle -The button element\n * @csspart icon-sun -The sun SVG icon\n * @csspart icon-moon -The moon SVG icon\n *\n * Usage:\n * ```html\n * <open-theme-toggle theme=\"light\"></open-theme-toggle>\n * ```\n */\n\nimport { OpenElement } from '@openelement/element';\nimport { StyleSheet, type StyleSheetLike } from '@openelement/core/style-sheet';\nimport { signal } from '@openelement/signal';\nexport const tagName = 'open-theme-toggle';\n\nconst sheet: StyleSheetLike = new StyleSheet();\nsheet.replaceSync(`\n  :host {\n    display: inline-block;\n  }\n\n  .theme-toggle {\n    display: inline-flex;\n    align-items: center;\n    justify-content: center;\n    width: 38px; height: 38px; padding: 0;\n    border: var(--border-size-1) solid color-mix(in srgb, var(--border) 72%, var(--brand));\n    border-radius: var(--radius-round);\n    background: color-mix(in srgb, var(--bg-elevated) 76%, transparent);\n    color: var(--text-muted);\n    box-shadow: inset 0 1px 0 color-mix(in srgb, var(--gray-0) 70%, transparent);\n    cursor: pointer;\n    transition: all var(--ease-2) var(--duration-2);\n  }\n  .theme-toggle:hover {\n    color: var(--text-primary);\n    border-color: var(--brand-light);\n    background: color-mix(in srgb, var(--brand-pale) 42%, var(--bg-elevated));\n  }\n\n  .theme-toggle svg {\n    width: 16px;\n    height: 16px;\n  }\n\n  .theme-toggle .icon-sun {\n    display: block;\n  }\n\n  .theme-toggle .icon-moon {\n    display: none;\n  }\n\n  .theme-toggle[data-theme=\"light\"] .icon-sun {\n    display: none;\n  }\n\n  .theme-toggle[data-theme=\"light\"] .icon-moon {\n    display: block;\n  }\n`);\n\nexport class OpenThemeToggle extends OpenElement {\n  // ponytail: Safari does not recompute adoptedStyleSheets when\n  // :host([data-theme]) changes. The token sheets (openPropsTokenSheet,\n  // daisyClassSheet) are already injected as page-level <style> by\n  // vite.config.ts — CSS custom properties cascade from :root naturally.\n  // Only adopt the component-specific sheet.\n  static override styles = [sheet];\n  static override delegatesFocus = true;\n  static override observedAttributes = ['theme'];\n\n  private _theme = signal<'dark' | 'light'>('dark');\n  private _initDone = false;\n\n  override connectedCallback(): void {\n    super.connectedCallback();\n    requestAnimationFrame(() => this._initTheme());\n  }\n\n  /**\n   * v0.23.0: Theme initialization lives in _initTheme(), called from\n   * both onDsdHydrated() and onCsrRendered() so that the priority\n   * chain works regardless of hydration path.\n   *\n   * Priority: theme attribute > document.documentElement.dataset.theme\n   * > localStorage > prefers-color-scheme > default 'dark'.\n   */\n  private _initTheme(): void {\n    if (this._initDone) return;\n    this._initDone = true;\n    const themeAttr = this.getAttribute('theme');\n    if (themeAttr === 'light') {\n      this._theme.value = 'light';\n    } else if (themeAttr === 'dark') {\n      this._theme.value = 'dark';\n    } else {\n      const docTheme = document.documentElement?.dataset?.theme;\n      if (docTheme === 'light') {\n        this._theme.value = 'light';\n      } else if (docTheme === 'dark') {\n        this._theme.value = 'dark';\n      } else {\n        let resolved = false;\n        try {\n          const saved = localStorage.getItem('open-theme');\n          if (saved === 'light') {\n            this._theme.value = 'light';\n            resolved = true;\n          } else if (saved === 'dark') {\n            this._theme.value = 'dark';\n            resolved = true;\n          }\n        } catch { /* localStorage blocked */ }\n        if (!resolved && globalThis.matchMedia) {\n          this._theme.value = globalThis.matchMedia('(prefers-color-scheme: light)').matches\n            ? 'light'\n            : 'dark';\n        }\n      }\n    }\n\n    this.setAttribute('data-theme', this._theme.value);\n    document.documentElement.setAttribute('data-theme', this._theme.value);\n    if (document.documentElement.style) {\n      document.documentElement.style.colorScheme = this._theme.value;\n    }\n    // Propagate to parent open-layout\n    try {\n      const root = this.getRootNode();\n      if (root instanceof ShadowRoot && root.host) {\n        root.host.setAttribute('data-theme', this._theme.value);\n      }\n    } catch { /* not in shadow DOM */ }\n    this._dispatchThemeChange(this._theme.value);\n    this._persistTheme(this._theme.value);\n  }\n\n  private _persistTheme(theme: 'dark' | 'light'): void {\n    try {\n      localStorage.setItem('open-theme', theme);\n    } catch { /* blocked */ }\n  }\n\n  protected override onDsdHydrated(): void {\n    super.onDsdHydrated();\n    requestAnimationFrame(() => this._initTheme());\n  }\n\n  protected override onCsrRendered(): void {\n    super.onCsrRendered();\n  }\n\n  override render(): ReturnType<typeof OpenElement.prototype.render> {\n    // Zero signal.value reads in render (ADR-0062).\n    // effect binding that updates the attribute when theme changes.\n    // CSS selectors ([data-theme=\"light\"]) handle icon visibility.\n    return (\n      <button\n        type='button'\n        className='theme-toggle'\n        part='toggle'\n        data-theme={this._theme}\n        aria-label='Toggle theme'\n        onClick={() => this._handleToggle()}\n      >\n        <svg\n          className='icon-sun'\n          part='icon-sun'\n          viewBox='0 0 16 16'\n          fill='none'\n          stroke='currentColor'\n          stroke-width='1.2'\n          stroke-linecap='round'\n        >\n          <circle cx='8' cy='8' r='3' />\n          <line x1='8' y1='1' x2='8' y2='3' />\n          <line x1='8' y1='13' x2='8' y2='15' />\n          <line x1='1' y1='8' x2='3' y2='8' />\n          <line x1='13' y1='8' x2='15' y2='8' />\n          <line x1='3.05' y1='3.05' x2='4.46' y2='4.46' />\n          <line x1='11.54' y1='11.54' x2='12.95' y2='12.95' />\n          <line x1='3.05' y1='12.95' x2='4.46' y2='11.54' />\n          <line x1='11.54' y1='4.46' x2='12.95' y2='3.05' />\n        </svg>\n        <svg\n          className='icon-moon'\n          part='icon-moon'\n          viewBox='0 0 16 16'\n          fill='none'\n          stroke='currentColor'\n          stroke-width='1.2'\n          stroke-linecap='round'\n        >\n          <path d='M13.5 9.14A5.5 5.5 0 0 1 6.86 2.5 5.5 5.5 0 1 0 13.5 9.14Z' />\n        </svg>\n      </button>\n    );\n  }\n\n  private _handleToggle(): void {\n    const theme = this._theme.value === 'light' ? 'dark' : 'light';\n    this._theme.value = theme;\n\n    document.documentElement.setAttribute('data-theme', theme);\n    if (document.documentElement.style) {\n      document.documentElement.style.colorScheme = theme;\n    }\n\n    // Propagate data-theme to parent <open-layout> so :host([data-theme=\"dark\"]) matches\n    try {\n      const root = this.getRootNode();\n      if (root instanceof ShadowRoot && root.host) {\n        root.host.setAttribute('data-theme', theme);\n      }\n    } catch (e) {\n      console.debug('[open-theme-toggle] getRootNode unavailable:', e);\n    }\n\n    this._dispatchThemeChange(theme);\n\n    try {\n      localStorage.setItem('open-theme', theme);\n    } catch (e) {\n      console.debug('[open-theme-toggle] localStorage.setItem unavailable:', e);\n    }\n    // data-theme attribute is managed by signal prop binding (data-theme={this._theme})\n  }\n\n  private _dispatchThemeChange(theme: 'dark' | 'light'): void {\n    try {\n      if (typeof CustomEvent !== 'undefined' && typeof globalThis.dispatchEvent === 'function') {\n        globalThis.dispatchEvent(new CustomEvent('open:theme-change', { detail: { theme } }));\n      }\n    } catch (e) {\n      console.debug('[open-theme-toggle] theme event dispatch unavailable:', e);\n    }\n  }\n\n  override attributeChangedCallback(name: string, old: string | null, val: string | null): void {\n    if (old === val) return;\n    if (name === 'theme' && val) {\n      this._theme.value = val === 'light' ? 'light' : 'dark';\n      this.setAttribute('data-theme', this._theme.value);\n    }\n  }\n}\n\nexport default OpenThemeToggle;\n\n// Guard: idempotent across SSR paths\nif (typeof customElements !== 'undefined' && !customElements.get(tagName)) {\n  customElements.define(tagName, OpenThemeToggle);\n}\n"],"names":[],"mappings":"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"}