@openelement/ui 0.41.0-alpha.1

package/src/open-input.js

@@ -0,0 +1,233 @@
+/** @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 { StyleSheet } from '@openelement/core/style-sheet';
+import { escapeAttr, escapeHtml } from '@openelement/core';
+export const tagName = 'open-input';
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: block;
+  }
+
+  .input-wrapper {
+    display: flex;
+    flex-direction: column;
+    gap: var(--size-2);
+  }
+
+  label {
+    font-size: var(--font-size-0);
+    font-weight: var(--font-weight-5);
+    color: var(--gray-6);
+    letter-spacing: var(--font-letterspacing-2);
+  }
+
+  .input {
+    width: 100%;
+    padding: var(--size-2) var(--size-3);
+    font-family: var(--font-sans);
+    font-size: var(--font-size-1);
+    color: var(--gray-9);
+    background: var(--gray-0);
+    border: var(--border-size-1) solid var(--gray-3);
+    border-radius: var(--radius-2);
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+    outline: none;
+  }
+
+  .input::placeholder {
+    color: var(--gray-5);
+  }
+
+  .input:hover {
+    border-color: var(--gray-5);
+  }
+
+  .input:focus {
+    border-color: var(--brand, var(--indigo-6));
+    box-shadow: 0 0 0 1px var(--brand, var(--indigo-6));
+  }
+
+  .input:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    background: var(--gray-1);
+  }
+
+  .input--error {
+    border-color: var(--error);
+  }
+
+  :host(:state(disabled)) .input {
+    opacity: 0.5;
+    cursor: not-allowed;
+    background: var(--gray-1);
+  }
+
+  :host(:state(invalid)) .input {
+    border-color: var(--error);
+  }
+
+  .error-message {
+    font-size: var(--font-size-00);
+    color: var(--error);
+  }
+`);
+export class OpenInput extends OpenElement {
+  static styles = [
+    sheet
+  ];
+  static formAssociated = true;
+  static delegatesFocus = true;
+  static observedAttributes = [
+    'type',
+    'placeholder',
+    'label',
+    'value',
+    'name',
+    'disabled',
+    'required',
+    'error'
+  ];
+  render() {
+    const type = this.getAttribute('type') || 'text';
+    const placeholder = this.getAttribute('placeholder') || '';
+    const label1 = this.getAttribute('label') || '';
+    const value = this.getAttribute('value') || '';
+    const name = this.getAttribute('name') || '';
+    const d = this.hasAttribute('disabled');
+    const r = this.hasAttribute('required');
+    const error = this.getAttribute('error') || '';
+    const errorClass = error ? ' input--error' : '';
+    return <div className='input-wrapper' part='wrapper'>
+        {label1 && <label htmlFor='input' part='label'>
+            {this._esc(label1)}
+            {r ? ' *' : ''}
+          </label>}
+        <input id='input' className={`input${errorClass}`} part='control' type={type} placeholder={placeholder} value={value} name={name} disabled={d} required={r} aria-invalid={error ? 'true' : undefined} aria-describedby={error ? 'input-error' : undefined} aria-errormessage={error ? 'input-error' : undefined} onInput={(e)=>this._handleInput(e)} onChange={(e)=>this._handleChange(e)} onFocus={()=>this._handleFocus()} onBlur={()=>this._handleBlur()}/>
+        {error && <small id='input-error' role='alert' className='error-message' part='error'>
+            {this._esc(error)}
+          </small>}
+      </div>;
+  }
+  attributeChangedCallback(name, old, val) {
+    if (old === val) return;
+    if (name === 'disabled' || name === 'error') {
+      this._syncDOM();
+      this._updateStates();
+    } else if (name === 'value') {
+      this._syncDOM();
+      if (this._internals) {
+        this._internals.setFormValue(val || '');
+      }
+    } else {
+      this._syncDOM();
+    }
+  }
+  _syncDOM() {
+    const input1 = this.shadowRoot?.querySelector('input, textarea, select');
+    if (!input1) return;
+    input1.disabled = this.hasAttribute('disabled');
+    const val = this.getAttribute('value');
+    if (val !== null && input1.value !== val) {
+      input1.value = val;
+    }
+  }
+  _updateStates() {
+    if (!this._internals?.states) return;
+    if (this.hasAttribute('disabled')) {
+      this._internals.states.add('disabled');
+      this._internals.states.delete('enabled');
+    } else {
+      this._internals.states.delete('disabled');
+      this._internals.states.add('enabled');
+    }
+    if (this.getAttribute('error')) {
+      this._internals.states.add('invalid');
+    } else {
+      this._internals.states.delete('invalid');
+    }
+  }
+  _handleInput(e) {
+    const input1 = e.target;
+    this.setAttribute('value', input1.value);
+    this._internals?.setFormValue(input1.value);
+    this.dispatchEvent(new CustomEvent('open-input', {
+      detail: {
+        value: input1.value
+      },
+      bubbles: true,
+      composed: false
+    }));
+  }
+  _handleChange(e) {
+    const input1 = e.target;
+    this.dispatchEvent(new CustomEvent('open-change', {
+      detail: {
+        value: input1.value
+      },
+      bubbles: true,
+      composed: false
+    }));
+  }
+  _handleFocus() {
+    this.dispatchEvent(new CustomEvent('open-focus', {
+      bubbles: true,
+      composed: false
+    }));
+  }
+  _handleBlur() {
+    this.dispatchEvent(new CustomEvent('open-blur', {
+      bubbles: true,
+      composed: false
+    }));
+  }
+  formResetCallback() {
+    this.setAttribute('value', '');
+    this.removeAttribute('error');
+    this._internals?.setFormValue('');
+    this._syncDOM();
+  }
+  formDisabledCallback(disabled) {
+    if (disabled) {
+      this.setAttribute('disabled', '');
+    } else {
+      this.removeAttribute('disabled');
+    }
+  }
+  _esc = escapeHtml;
+  _escAttr = escapeAttr;
+}
+export default OpenInput;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenInput);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/open-input.tsx"],"sourcesContent":["/** @jsxImportSource @openelement/core */\n/**\n * @openelement/ui - open-input\n *\n * Minimal input field following Swiss International Style.\n * Clean borders, subtle focus states.\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 * Features:\n * - Form-associated: participates in native <form> submission\n * - Supports label, placeholder, error, disabled, required\n * - Dispatches 'open-input' custom event on value change\n *\n * @csspart wrapper -The outer input-wrapper div\n * @csspart label -The label element\n * @csspart control -The input/textarea/select element\n * @csspart error -The error message small element\n *\n * Usage:\n * ```html\n * <open-input placeholder=\"Enter text\"></open-input>\n * <open-input type=\"email\" label=\"Email\"></open-input>\n * <form onsubmit=\"console.info(new FormData(this))\">\n *   <open-input name=\"username\" label=\"Username\"></open-input>\n *   <button type=\"submit\">Submit</button>\n * </form>\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-input';\n\nconst sheet: StyleSheetLike = new StyleSheet();\nsheet.replaceSync(`\n  :host {\n    display: block;\n  }\n\n  .input-wrapper {\n    display: flex;\n    flex-direction: column;\n    gap: var(--size-2);\n  }\n\n  label {\n    font-size: var(--font-size-0);\n    font-weight: var(--font-weight-5);\n    color: var(--gray-6);\n    letter-spacing: var(--font-letterspacing-2);\n  }\n\n  .input {\n    width: 100%;\n    padding: var(--size-2) var(--size-3);\n    font-family: var(--font-sans);\n    font-size: var(--font-size-1);\n    color: var(--gray-9);\n    background: var(--gray-0);\n    border: var(--border-size-1) solid var(--gray-3);\n    border-radius: var(--radius-2);\n    transition: border-color 0.2s ease, box-shadow 0.2s ease;\n    outline: none;\n  }\n\n  .input::placeholder {\n    color: var(--gray-5);\n  }\n\n  .input:hover {\n    border-color: var(--gray-5);\n  }\n\n  .input:focus {\n    border-color: var(--brand, var(--indigo-6));\n    box-shadow: 0 0 0 1px var(--brand, var(--indigo-6));\n  }\n\n  .input:disabled {\n    opacity: 0.5;\n    cursor: not-allowed;\n    background: var(--gray-1);\n  }\n\n  .input--error {\n    border-color: var(--error);\n  }\n\n  :host(:state(disabled)) .input {\n    opacity: 0.5;\n    cursor: not-allowed;\n    background: var(--gray-1);\n  }\n\n  :host(:state(invalid)) .input {\n    border-color: var(--error);\n  }\n\n  .error-message {\n    font-size: var(--font-size-00);\n    color: var(--error);\n  }\n`);\n\nexport class OpenInput extends OpenElement {\n  static override styles = [sheet];\n  static override formAssociated = true;\n  static override delegatesFocus = true;\n  static override observedAttributes = [\n    'type',\n    'placeholder',\n    'label',\n    'value',\n    'name',\n    'disabled',\n    'required',\n    'error',\n  ];\n\n  override render(): ReturnType<typeof OpenElement.prototype.render> {\n    const type = this.getAttribute('type') || 'text';\n    const placeholder = this.getAttribute('placeholder') || '';\n    const label = this.getAttribute('label') || '';\n    const value = this.getAttribute('value') || '';\n    const name = this.getAttribute('name') || '';\n    const d = this.hasAttribute('disabled');\n    const r = this.hasAttribute('required');\n    const error = this.getAttribute('error') || '';\n    const errorClass = error ? ' input--error' : '';\n\n    return (\n      <div className='input-wrapper' part='wrapper'>\n        {label && (\n          <label htmlFor='input' part='label'>\n            {this._esc(label)}\n            {r ? ' *' : ''}\n          </label>\n        )}\n        <input\n          id='input'\n          className={`input${errorClass}`}\n          part='control'\n          type={type}\n          placeholder={placeholder}\n          value={value}\n          name={name}\n          disabled={d}\n          required={r}\n          aria-invalid={error ? 'true' : undefined}\n          aria-describedby={error ? 'input-error' : undefined}\n          aria-errormessage={error ? 'input-error' : undefined}\n          onInput={(e: Event) => this._handleInput(e)}\n          onChange={(e: Event) => this._handleChange(e)}\n          onFocus={() => this._handleFocus()}\n          onBlur={() => this._handleBlur()}\n        />\n        {error && (\n          <small id='input-error' role='alert' className='error-message' part='error'>\n            {this._esc(error)}\n          </small>\n        )}\n      </div>\n    );\n  }\n\n  override attributeChangedCallback(name: string, old: string | null, val: string | null): void {\n    if (old === val) return;\n    if (name === 'disabled' || name === 'error') {\n      this._syncDOM();\n      this._updateStates();\n    } else if (name === 'value') {\n      this._syncDOM();\n      if (this._internals) {\n        this._internals.setFormValue(val || '');\n      }\n    } else {\n      this._syncDOM();\n    }\n  }\n\n  private _syncDOM(): void {\n    const input = this.shadowRoot?.querySelector('input, textarea, select') as\n      | HTMLInputElement\n      | null;\n    if (!input) return;\n    input.disabled = this.hasAttribute('disabled');\n    const val = this.getAttribute('value');\n    if (val !== null && input.value !== val) {\n      input.value = val;\n    }\n  }\n\n  private _updateStates(): void {\n    if (!this._internals?.states) return;\n    if (this.hasAttribute('disabled')) {\n      this._internals.states.add('disabled');\n      this._internals.states.delete('enabled');\n    } else {\n      this._internals.states.delete('disabled');\n      this._internals.states.add('enabled');\n    }\n    if (this.getAttribute('error')) {\n      this._internals.states.add('invalid');\n    } else {\n      this._internals.states.delete('invalid');\n    }\n  }\n\n  private _handleInput(e: Event): void {\n    const input = e.target as HTMLInputElement;\n    this.setAttribute('value', input.value);\n    this._internals?.setFormValue(input.value);\n    this.dispatchEvent(\n      new CustomEvent('open-input', {\n        detail: { value: input.value },\n        bubbles: true,\n        composed: false,\n      }),\n    );\n  }\n\n  private _handleChange(e: Event): void {\n    const input = e.target as HTMLInputElement;\n    this.dispatchEvent(\n      new CustomEvent('open-change', {\n        detail: { value: input.value },\n        bubbles: true,\n        composed: false,\n      }),\n    );\n  }\n\n  private _handleFocus(): void {\n    this.dispatchEvent(new CustomEvent('open-focus', { bubbles: true, composed: false }));\n  }\n\n  private _handleBlur(): void {\n    this.dispatchEvent(new CustomEvent('open-blur', { bubbles: true, composed: false }));\n  }\n\n  formResetCallback(): void {\n    this.setAttribute('value', '');\n    this.removeAttribute('error');\n    this._internals?.setFormValue('');\n    this._syncDOM();\n  }\n\n  formDisabledCallback(disabled: boolean): void {\n    if (disabled) {\n      this.setAttribute('disabled', '');\n    } else {\n      this.removeAttribute('disabled');\n    }\n  }\n\n  private _esc = escapeHtml;\n  private _escAttr = escapeAttr;\n}\n\nexport default OpenInput;\n\n// Guard: idempotent across SSR paths\nif (typeof customElements !== 'undefined' && !customElements.get(tagName)) {\n  customElements.define(tagName, OpenInput);\n}\n"],"names":[],"mappings":"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"}

package/src/open-lab-panel.d.ts

@@ -0,0 +1,16 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-lab-panel
+ *
+ * Standards-lab panel for specs, artifact frames, and reference desks.
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-lab-panel';
+declare const sheet: StyleSheetLike;
+export declare class OpenLabPanel extends OpenElement {
+  static override styles: [];
+  static override observedAttributes: [string, string, string, string];
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  private _esc: any;
+  private _getStr: any;
+}
+export default OpenLabPanel;

package/src/open-lab-panel.js

@@ -0,0 +1,151 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-lab-panel
+ *
+ * Standards-lab panel for specs, artifact frames, and reference desks.
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+import { escapeHtml } from '@openelement/core';
+export const tagName = 'open-lab-panel';
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: block;
+  }
+
+  .panel {
+    display: grid;
+    grid-template-rows: auto minmax(0, 1fr);
+    min-height: var(--panel-min-height, auto);
+    overflow: hidden;
+    border: var(--border-size-1) solid var(--border);
+    border-radius: var(--radius-3);
+    background:
+      linear-gradient(135deg, color-mix(in srgb, var(--violet-1) 18%, transparent), transparent 44%),
+      var(--bg-card);
+    color: var(--text-primary);
+    box-shadow: 0 var(--size-2) var(--size-8) color-mix(in srgb, var(--brand) 8%, transparent);
+  }
+
+  .panel--muted {
+    background: var(--bg-surface);
+  }
+
+  .panel--artifact,
+  .panel--code {
+    background: var(--bg-code, var(--gray-11));
+    color: var(--code-text);
+    border-color: var(--code-border, var(--gray-8));
+  }
+
+  .panel__bar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--size-4);
+    min-height: var(--size-10);
+    padding: var(--size-2) var(--size-4);
+    border-bottom: var(--border-size-1) solid var(--border);
+    background: color-mix(in srgb, var(--bg-surface) 78%, transparent);
+  }
+
+  .panel--artifact .panel__bar,
+  .panel--code .panel__bar {
+    border-bottom-color: var(--code-border, var(--gray-8));
+    background: color-mix(in srgb, var(--gray-12) 8%, transparent);
+  }
+
+  .panel__label {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--size-2);
+    min-width: 0;
+    color: var(--text-muted);
+    font-family: var(--font-mono);
+    font-size: var(--font-size-00);
+    font-weight: var(--font-weight-8);
+    letter-spacing: 0;
+    text-transform: uppercase;
+  }
+
+  .panel--artifact .panel__label,
+  .panel--code .panel__label {
+    color: var(--gray-5);
+  }
+
+  .panel__dot {
+    width: var(--size-2);
+    height: var(--size-2);
+    border-radius: var(--radius-round);
+    background: var(--brand);
+    box-shadow:
+      calc(var(--size-3) * -1) 0 0 var(--warning),
+      var(--size-3) 0 0 var(--success);
+    margin-inline: var(--size-3) var(--size-2);
+    flex: 0 0 auto;
+  }
+
+  .panel__meta {
+    color: var(--text-muted);
+    font-family: var(--font-mono);
+    font-size: var(--font-size-00);
+    white-space: nowrap;
+  }
+
+  .panel--artifact .panel__meta,
+  .panel--code .panel__meta {
+    color: var(--gray-6);
+  }
+
+  .panel__body {
+    min-width: 0;
+    padding: var(--size-5);
+  }
+
+  :host([compact]) .panel__body {
+    padding: var(--size-4);
+  }
+
+  ::slotted(*) {
+    margin-block-start: 0;
+  }
+`);
+export class OpenLabPanel extends OpenElement {
+  static styles = [
+    sheet
+  ];
+  static observedAttributes = [
+    'variant',
+    'label',
+    'meta',
+    'compact'
+  ];
+  render() {
+    const variant = this._getStr('variant', 'surface');
+    const label = this._getStr('label', '');
+    const meta = this._getStr('meta', '');
+    return <section className={`panel panel--${variant}`} part='container'>
+        {(label || meta) && <header className='panel__bar' part='header'>
+            <span className='panel__label'>
+              <span className='panel__dot' aria-hidden='true'></span>
+              {this._esc(label)}
+            </span>
+            {meta && <span className='panel__meta'>{this._esc(meta)}</span>}
+          </header>}
+        <div className='panel__body' part='body'>
+          <slot></slot>
+        </div>
+      </section>;
+  }
+  _esc = escapeHtml;
+  _getStr(attr, def) {
+    const camel = attr.replace(/-([a-z])/g, (_, c)=>c.toUpperCase());
+    const prop = this[camel] ?? this[attr];
+    if (prop !== undefined && prop !== null) return String(prop);
+    return this.getAttribute(attr) || def;
+  }
+}
+export default OpenLabPanel;
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenLabPanel);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/open-lab-panel.tsx"],"sourcesContent":["/** @jsxImportSource @openelement/core */\n/**\n * @openelement/ui - open-lab-panel\n *\n * Standards-lab panel for specs, artifact frames, and reference desks.\n */\n\nimport { OpenElement } from '@openelement/element';\nimport { StyleSheet, type StyleSheetLike } from '@openelement/core/style-sheet';\nimport { escapeHtml } from '@openelement/core';\n\nexport const tagName = 'open-lab-panel';\n\nconst sheet: StyleSheetLike = new StyleSheet();\nsheet.replaceSync(`\n  :host {\n    display: block;\n  }\n\n  .panel {\n    display: grid;\n    grid-template-rows: auto minmax(0, 1fr);\n    min-height: var(--panel-min-height, auto);\n    overflow: hidden;\n    border: var(--border-size-1) solid var(--border);\n    border-radius: var(--radius-3);\n    background:\n      linear-gradient(135deg, color-mix(in srgb, var(--violet-1) 18%, transparent), transparent 44%),\n      var(--bg-card);\n    color: var(--text-primary);\n    box-shadow: 0 var(--size-2) var(--size-8) color-mix(in srgb, var(--brand) 8%, transparent);\n  }\n\n  .panel--muted {\n    background: var(--bg-surface);\n  }\n\n  .panel--artifact,\n  .panel--code {\n    background: var(--bg-code, var(--gray-11));\n    color: var(--code-text);\n    border-color: var(--code-border, var(--gray-8));\n  }\n\n  .panel__bar {\n    display: flex;\n    align-items: center;\n    justify-content: space-between;\n    gap: var(--size-4);\n    min-height: var(--size-10);\n    padding: var(--size-2) var(--size-4);\n    border-bottom: var(--border-size-1) solid var(--border);\n    background: color-mix(in srgb, var(--bg-surface) 78%, transparent);\n  }\n\n  .panel--artifact .panel__bar,\n  .panel--code .panel__bar {\n    border-bottom-color: var(--code-border, var(--gray-8));\n    background: color-mix(in srgb, var(--gray-12) 8%, transparent);\n  }\n\n  .panel__label {\n    display: inline-flex;\n    align-items: center;\n    gap: var(--size-2);\n    min-width: 0;\n    color: var(--text-muted);\n    font-family: var(--font-mono);\n    font-size: var(--font-size-00);\n    font-weight: var(--font-weight-8);\n    letter-spacing: 0;\n    text-transform: uppercase;\n  }\n\n  .panel--artifact .panel__label,\n  .panel--code .panel__label {\n    color: var(--gray-5);\n  }\n\n  .panel__dot {\n    width: var(--size-2);\n    height: var(--size-2);\n    border-radius: var(--radius-round);\n    background: var(--brand);\n    box-shadow:\n      calc(var(--size-3) * -1) 0 0 var(--warning),\n      var(--size-3) 0 0 var(--success);\n    margin-inline: var(--size-3) var(--size-2);\n    flex: 0 0 auto;\n  }\n\n  .panel__meta {\n    color: var(--text-muted);\n    font-family: var(--font-mono);\n    font-size: var(--font-size-00);\n    white-space: nowrap;\n  }\n\n  .panel--artifact .panel__meta,\n  .panel--code .panel__meta {\n    color: var(--gray-6);\n  }\n\n  .panel__body {\n    min-width: 0;\n    padding: var(--size-5);\n  }\n\n  :host([compact]) .panel__body {\n    padding: var(--size-4);\n  }\n\n  ::slotted(*) {\n    margin-block-start: 0;\n  }\n`);\n\nexport class OpenLabPanel extends OpenElement {\n  static override styles = [sheet];\n  static override observedAttributes = ['variant', 'label', 'meta', 'compact'];\n\n  override render(): ReturnType<typeof OpenElement.prototype.render> {\n    const variant = this._getStr('variant', 'surface');\n    const label = this._getStr('label', '');\n    const meta = this._getStr('meta', '');\n\n    return (\n      <section className={`panel panel--${variant}`} part='container'>\n        {(label || meta) && (\n          <header className='panel__bar' part='header'>\n            <span className='panel__label'>\n              <span className='panel__dot' aria-hidden='true'></span>\n              {this._esc(label)}\n            </span>\n            {meta && <span className='panel__meta'>{this._esc(meta)}</span>}\n          </header>\n        )}\n        <div className='panel__body' part='body'>\n          <slot></slot>\n        </div>\n      </section>\n    );\n  }\n\n  private _esc = escapeHtml;\n\n  private _getStr(attr: string, def: string): string {\n    const camel = attr.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());\n    const prop = (this as Record<string, unknown>)[camel] ??\n      (this as Record<string, unknown>)[attr];\n    if (prop !== undefined && prop !== null) return String(prop);\n    return this.getAttribute(attr) || def;\n  }\n}\n\nexport default OpenLabPanel;\n\nif (typeof customElements !== 'undefined' && !customElements.get(tagName)) {\n  customElements.define(tagName, OpenLabPanel);\n}\n"],"names":[],"mappings":"AAAA,uCAAuC,GACvC;;;;CAIC,GAED,SAAS,WAAW,QAAQ,uBAAuB;AACnD,SAAS,UAAU,QAA6B,gCAAgC;AAChF,SAAS,UAAU,QAAQ,oBAAoB;AAE/C,OAAO,MAAM,UAAU,iBAAiB;AAExC,MAAM,QAAwB,IAAI;AAClC,MAAM,WAAW,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGnB,CAAC;AAED,OAAO,MAAM,qBAAqB;EAChC,OAAgB,SAAS;IAAC;GAAM,CAAC;EACjC,OAAgB,qBAAqB;IAAC;IAAW;IAAS;IAAQ;GAAU,CAAC;EAEpE,SAA0D;IACjE,MAAM,UAAU,IAAI,CAAC,OAAO,CAAC,WAAW;IACxC,MAAM,QAAQ,IAAI,CAAC,OAAO,CAAC,SAAS;IACpC,MAAM,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ;IAElC,QACG,QAAQ,WAAW,CAAC,aAAa,EAAE,SAAS,EAAE,KAAK,YAAY;QAC9D,CAAC,CAAC,SAAS,IAAI,MACZ,OAAO,UAAU,aAAa,KAAK,SAAS;YAC3C,CAAC,KAAK,UAAU,eAAe;cAC7B,CAAC,KAAK,UAAU,aAAa,YAAY,SAAS,KAAK;cACvD,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO;YACpB,EAAE,KAAK;YACP,CAAC,SAAS,KAAK,UAAU,eAAe,IAAI,CAAC,IAAI,CAAC,QAAQ,MAAM;UAClE,EAAE,QACF;QACF,CAAC,IAAI,UAAU,cAAc,KAAK,OAAO;UACvC,CAAC,OAAO,KAAK;QACf,EAAE,IAAI;MACR,EAAE;EAEN;EAEQ,OAAO,WAAW;EAElB,QAAQ,IAAY,EAAE,GAAW,EAAU;IACjD,MAAM,QAAQ,KAAK,OAAO,CAAC,aAAa,CAAC,GAAG,IAAc,EAAE,WAAW;IACvE,MAAM,OAAO,AAAC,IAAI,AAA4B,CAAC,MAAM,IACnD,AAAC,IAAI,AAA4B,CAAC,KAAK;IACzC,IAAI,SAAS,aAAa,SAAS,MAAM,OAAO,OAAO;IACvD,OAAO,IAAI,CAAC,YAAY,CAAC,SAAS;EACpC;AACF;AAEA,eAAe,aAAa;AAE5B,IAAI,OAAO,mBAAmB,eAAe,CAAC,eAAe,GAAG,CAAC,UAAU;EACzE,eAAe,MAAM,CAAC,SAAS;AACjC"}

package/src/open-lab-stage.d.ts

@@ -0,0 +1,15 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-lab-stage
+ *
+ * Kinetic standards-lab hero primitive for product-art landing pages.
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-lab-stage';
+declare const sheet: StyleSheetLike;
+export declare class OpenLabStage extends OpenElement {
+  static override styles: [];
+  static override observedAttributes: [string, string];
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  private _getStr: any;
+}
+export default OpenLabStage;