@openelement/ui 0.41.0-alpha.1

package/src/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @openelement/ui - openElement UI Component Library
+ *
+ * Swiss International Style: Pure B&W, minimal, typography-driven.
+ * Zero Lit dependency - built on DsdElement (native HTMLElement).
+ *
+ * Components:
+ * - open-button: Button with variants (default, primary, ghost, accent)
+ * - open-card: Card container with optional header/footer
+ * - open-input: Input field with label and error states
+ * - open-code-block: Code block with copy button
+ * - open-badge: Open Props status badge
+ * - open-brand-mark: Aperture O brand mark
+ * - open-lab-panel: Standards-lab artifact/spec panel
+ * - open-lab-stage: Kinetic standards-lab hero primitive
+ * - open-standards-visual: Product-art standards diagrams
+ * - open-layout: App layout with header, sidebar, footer
+ * - open-theme-toggle: Theme toggle Island (Dark/Light)
+ * - open-dialog: Dialog component using native <dialog>
+ * - open-callout: Callout/notice box (info/warning/danger/tip)
+ * - open-step-card: Step card with numbered indicator
+ * - open-dropdown: Dropdown toggle with trigger slot and content slot
+ * - open-modal: Modal dialog using signal-driven open attribute
+ * - open-tabs: Tab interface with tab and panel slots
+ *
+ * Usage:
+ * ```ts
+ * // Import all components
+ * import '@openelement/ui';
+ *
+ * // Or import specific components
+ * import { OpenButton } from '@openelement/ui/open-button';
+ * ```
+ *
+ * @module @openelement/ui
+ */ export { openPropsTokenSheet } from "./open-props-tokens.js";
+export { daisyClassSheet } from "./daisy-classes.js";
+export { OpenButton, tagName as openButtonTagName } from "./open-button.js";
+export { OpenCard, tagName as openCardTagName } from "./open-card.js";
+export { OpenInput, tagName as openInputTagName } from "./open-input.js";
+export { OpenCodeBlock, tagName as openCodeBlockTagName } from "./open-code-block.js";
+export { OpenBadge, tagName as openBadgeTagName } from "./open-badge.js";
+export { OpenBrandMark, tagName as openBrandMarkTagName } from "./open-brand-mark.js";
+export { OpenLabPanel, tagName as openLabPanelTagName } from "./open-lab-panel.js";
+export { OpenLabStage, tagName as openLabStageTagName } from "./open-lab-stage.js";
+export { OpenStandardsVisual, tagName as openStandardsVisualTagName } from "./open-standards-visual.js";
+export { OpenLayout, tagName as openLayoutTagName } from "./open-layout.js";
+export type { HeaderNavLink, NavItem, NavSection } from "./open-layout.js";
+export { OpenThemeToggle, tagName as openThemeToggleTagName } from "./open-theme-toggle.js";
+export { default as OpenHeroPing, tagName as openHeroPingTagName } from "./open-hero-ping.js";
+export { OpenDialog, tagName as openDialogTagName } from "./open-dialog.js";
+export { OpenCallout, tagName as openCalloutTagName } from "./open-callout.js";
+export { OpenStepCard, tagName as openStepCardTagName } from "./open-step-card.js";
+export { OpenDropdown, tagName as openDropdownTagName } from "./open-dropdown.js";
+export { OpenModal, tagName as openModalTagName } from "./open-modal.js";
+export { OpenTabs, tagName as openTabsTagName } from "./open-tabs.js";
+export { manifest } from "./manifest.js";

package/src/index.js

@@ -0,0 +1,62 @@
+/**
+ * @openelement/ui - openElement UI Component Library
+ *
+ * Swiss International Style: Pure B&W, minimal, typography-driven.
+ * Zero Lit dependency - built on DsdElement (native HTMLElement).
+ *
+ * Components:
+ * - open-button: Button with variants (default, primary, ghost, accent)
+ * - open-card: Card container with optional header/footer
+ * - open-input: Input field with label and error states
+ * - open-code-block: Code block with copy button
+ * - open-badge: Open Props status badge
+ * - open-brand-mark: Aperture O brand mark
+ * - open-lab-panel: Standards-lab artifact/spec panel
+ * - open-lab-stage: Kinetic standards-lab hero primitive
+ * - open-standards-visual: Product-art standards diagrams
+ * - open-layout: App layout with header, sidebar, footer
+ * - open-theme-toggle: Theme toggle Island (Dark/Light)
+ * - open-dialog: Dialog component using native <dialog>
+ * - open-callout: Callout/notice box (info/warning/danger/tip)
+ * - open-step-card: Step card with numbered indicator
+ * - open-dropdown: Dropdown toggle with trigger slot and content slot
+ * - open-modal: Modal dialog using signal-driven open attribute
+ * - open-tabs: Tab interface with tab and panel slots
+ *
+ * Usage:
+ * ```ts
+ * // Import all components
+ * import '@openelement/ui';
+ *
+ * // Or import specific components
+ * import { OpenButton } from '@openelement/ui/open-button';
+ * ```
+ *
+ * @module @openelement/ui
+ */ // Design tokens (CSSStyleSheet, zero Lit dependency)
+export { openPropsTokenSheet } from './open-props-tokens.js';
+// daisyUI forked class sheet (Pure CSS, Open Props tokens)
+export { daisyClassSheet } from './daisy-classes.js';
+// Components
+export { OpenButton, tagName as openButtonTagName } from './open-button.js';
+export { OpenCard, tagName as openCardTagName } from './open-card.js';
+export { OpenInput, tagName as openInputTagName } from './open-input.js';
+export { OpenCodeBlock, tagName as openCodeBlockTagName } from './open-code-block.js';
+export { OpenBadge, tagName as openBadgeTagName } from './open-badge.js';
+export { OpenBrandMark, tagName as openBrandMarkTagName } from './open-brand-mark.js';
+export { OpenLabPanel, tagName as openLabPanelTagName } from './open-lab-panel.js';
+export { OpenLabStage, tagName as openLabStageTagName } from './open-lab-stage.js';
+export { OpenStandardsVisual, tagName as openStandardsVisualTagName } from './open-standards-visual.js';
+export { OpenLayout, tagName as openLayoutTagName } from './open-layout.js';
+export { OpenThemeToggle, tagName as openThemeToggleTagName } from './open-theme-toggle.js';
+export { default as OpenHeroPing, tagName as openHeroPingTagName } from './open-hero-ping.js';
+export { OpenDialog, tagName as openDialogTagName } from './open-dialog.js';
+export { OpenCallout, tagName as openCalloutTagName } from './open-callout.js';
+export { OpenStepCard, tagName as openStepCardTagName } from './open-step-card.js';
+export { OpenDropdown, tagName as openDropdownTagName } from './open-dropdown.js';
+export { OpenModal, tagName as openModalTagName } from './open-modal.js';
+export { OpenTabs, tagName as openTabsTagName } from './open-tabs.js';
+// Package manifest (WC Package Protocol)
+// Consumers (adapter-vite) read manifest.declarations to derive island metadata.
+export { manifest } from './manifest.js';
+//# sourceMappingURL=data:application/json;base64,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

package/src/manifest.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @openelement/ui - Generated Package Manifest
+ *
+ * Scans component source files at runtime and builds a CEM-compatible
+ * OpenElementPackageManifest. Keeps the same export shape as the previous
+ * hand-written manifest so consumers continue to work.
+ */ import type { OpenElementPackageManifest } from '@openelement/protocol/manifest';
+export declare const manifest: OpenElementPackageManifest;

package/src/manifest.js

@@ -0,0 +1,255 @@
+import { Deno } from "@deno/shim-deno";
+const pkgVersion = '0.40.8';
+const COMPONENT_ORDER = [
+  'open-card',
+  'open-callout',
+  'open-step-card',
+  'open-button',
+  'open-input',
+  'open-theme-toggle',
+  'open-code-block',
+  'open-badge',
+  'open-brand-mark',
+  'open-lab-panel',
+  'open-standards-visual',
+  'open-lab-stage',
+  'open-dialog',
+  'open-layout',
+  'open-dropdown',
+  'open-modal',
+  'open-tabs',
+  'open-hero-ping'
+];
+function layerFromClass(className) {
+  const interactive = new Set([
+    'OpenButton',
+    'OpenInput',
+    'OpenThemeToggle',
+    'OpenDialog',
+    'OpenLayout',
+    'OpenDropdown',
+    'OpenModal',
+    'OpenTabs',
+    'OpenHeroPing'
+  ]);
+  return interactive.has(className) ? 'dsd-interactive' : 'dsd-static';
+}
+function hydrateFromClass(className) {
+  const load = new Set([
+    'OpenButton',
+    'OpenInput',
+    'OpenThemeToggle',
+    'OpenLayout',
+    'OpenDropdown',
+    'OpenModal',
+    'OpenTabs'
+  ]);
+  return load.has(className) ? 'load' : 'idle';
+}
+function inferAttributeType(name) {
+  if (name === 'disabled' || name === 'compact' || name === 'open' || name === 'home' || name === 'required') {
+    return 'boolean';
+  }
+  if (name === 'step') return 'number';
+  if (name === 'nav-items' || name === 'header-nav' || name === 'locales') return 'array';
+  return 'string';
+}
+function parseObservedAttributes(text) {
+  const match = text.match(/static\s+(?:override\s+)?observedAttributes\s*=\s*\[([\s\S]*?)\]/);
+  if (!match) return [];
+  return match[1].split(/,\s*/).map((s)=>s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean);
+}
+function parseTagName(text) {
+  const match = text.match(/export\s+const\s+tagName\s*=\s*['"]([^'"]+)['"]/);
+  if (!match) throw new Error('Could not find tagName export');
+  return match[1];
+}
+function parseClassName(text, file) {
+  const match = text.match(/export\s+(?:default\s+)?class\s+(\w+)\s+extends\s+OpenElement/);
+  if (!match) throw new Error(`Could not find exported class in ${file}`);
+  return match[1];
+}
+function parseCssParts(text) {
+  const parts = [];
+  const seen = new Set();
+  for (const m of text.matchAll(/\*\s*@csspart\s+(\S+)\s*-+(.*)/g)){
+    const name = m[1].trim();
+    const description = m[2].trim();
+    if (!seen.has(name)) {
+      seen.add(name);
+      parts.push({
+        name,
+        description
+      });
+    }
+  }
+  return parts;
+}
+function parseSlots(text) {
+  const slots = [];
+  const seen = new Set();
+  for (const m of text.matchAll(/\*\s*@slot\s+(\S*)\s*-+(.*)/g)){
+    const name = m[1].trim();
+    const description = m[2].trim();
+    if (!seen.has(name)) {
+      seen.add(name);
+      slots.push({
+        name,
+        description
+      });
+    }
+  }
+  // Default slot fallback when render includes <slot></slot> but no @slot -
+  if (text.includes('<slot></slot>') || text.includes('<slot ')) {
+    if (!seen.has('')) {
+      slots.unshift({
+        name: '',
+        description: 'Default slot'
+      });
+    }
+  }
+  return slots;
+}
+function parseEvents(text) {
+  const events = [];
+  const seen = new Set();
+  for (const m of text.matchAll(/new\s+CustomEvent\(['"]([^'"]+)['"],?\s*(?:\{([^}]*)\})?/g)){
+    const name = m[1];
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const detail = (m[2] || '').match(/detail\s*:\s*\{([^}]*)\}/);
+    events.push({
+      name,
+      type: detail ? `CustomEvent<{ ${detail[1].trim()} }>` : 'CustomEvent',
+      description: `Fired on ${name}`
+    });
+  }
+  return events;
+}
+function parseDescription(text) {
+  const lines = text.split('\n');
+  for(let i = 0; i < lines.length; i++){
+    const line = lines[i].trim();
+    if (line.startsWith('* @openelement/ui')) {
+      const next = lines[i + 1]?.replace(/^\s*\*\s?/, '').trim();
+      if (next && !next.startsWith('*') && !next.startsWith('@')) return next;
+    }
+  }
+  return '';
+}
+function buildMeta(file, source) {
+  const tagName = parseTagName(source);
+  const className = parseClassName(source, file);
+  const observed = parseObservedAttributes(source);
+  const attributes = observed.map((name)=>({
+      name,
+      type: inferAttributeType(name),
+      description: `${name} attribute`
+    }));
+  // Provide defaults for known boolean attributes
+  for (const attr of attributes){
+    if (attr.type === 'boolean') {
+      attr.default = 'false';
+    }
+  }
+  return {
+    file,
+    tagName,
+    className,
+    description: parseDescription(source),
+    attributes,
+    events: parseEvents(source),
+    slots: parseSlots(source),
+    cssParts: parseCssParts(source),
+    layer: layerFromClass(className),
+    hydrate: hydrateFromClass(className)
+  };
+}
+function readComponentSources() {
+  const dir = new URL('.', import.meta.url);
+  const metas = [];
+  for (const entry of Deno.readDirSync(dir)){
+    if (!entry.isFile || !entry.name.startsWith('open-') || !entry.name.endsWith('.tsx')) continue;
+    const file = entry.name;
+    const source = new TextDecoder().decode(Deno.readFileSync(new URL(file, dir)));
+    if (!source.includes('extends OpenElement')) continue;
+    metas.push(buildMeta(file, source));
+  }
+  const order = new Map(COMPONENT_ORDER.map((t, i)=>[
+      t,
+      i
+    ]));
+  metas.sort((a, b)=>(order.get(a.tagName) ?? 999) - (order.get(b.tagName) ?? 999));
+  return metas;
+}
+function buildDeclaration(meta) {
+  return {
+    tagName: meta.tagName,
+    className: meta.className,
+    superclassName: 'OpenElement',
+    description: meta.description,
+    attributes: meta.attributes.length ? meta.attributes : undefined,
+    events: meta.events.length ? meta.events : undefined,
+    slots: meta.slots.length ? meta.slots : undefined,
+    cssParts: meta.cssParts.length ? meta.cssParts : undefined,
+    openElement: {
+      ssr: true,
+      dsd: true,
+      layer: meta.layer,
+      hydrate: meta.hydrate,
+      module: `@openelement/ui/${meta.file.replace(/\.tsx$/, '')}`,
+      export: meta.className
+    }
+  };
+}
+function buildManifest() {
+  const metas = readComponentSources();
+  const declarations = metas.map(buildDeclaration);
+  const modules = metas.map((meta)=>({
+      path: `./${meta.file.replace(/\.tsx$/, '.js')}`,
+      exports: [
+        {
+          name: meta.className,
+          path: `./${meta.file.replace(/\.tsx$/, '.js')}`
+        }
+      ],
+      declarations: [
+        meta.tagName
+      ]
+    }));
+  return {
+    schemaVersion: '1.0.0',
+    packageName: '@openelement/ui',
+    version: pkgVersion,
+    description: 'Open Props Web Component library for openElement',
+    author: 'openElement',
+    license: 'MIT',
+    homepage: 'https://openelement.org',
+    repository: 'https://github.com/open-element/openelement',
+    openElement: {
+      adapter: 'vanilla',
+      hasStylesheet: true,
+      cssPrefix: 'open'
+    },
+    declarations,
+    modules
+  };
+}
+// ponytail: lazy-initialized to keep Deno runtime calls out of client bundles.
+// buildManifest() scans the filesystem and must only execute at build time.
+let _manifest;
+export const manifest = new Proxy({}, {
+  get (_target, prop) {
+    if (!_manifest) _manifest = buildManifest();
+    return _manifest[prop];
+  },
+  ownKeys () {
+    if (!_manifest) _manifest = buildManifest();
+    return Reflect.ownKeys(_manifest);
+  },
+  getOwnPropertyDescriptor (_target, prop) {
+    if (!_manifest) _manifest = buildManifest();
+    return Reflect.getOwnPropertyDescriptor(_manifest, prop);
+  }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/manifest.ts"],"sourcesContent":["import { Deno } from \"@deno/shim-deno\";\n/**\n * @openelement/ui - Generated Package Manifest\n *\n * Scans component source files at runtime and builds a CEM-compatible\n * OpenElementPackageManifest. Keeps the same export shape as the previous\n * hand-written manifest so consumers continue to work.\n */\n// deno-api-free:ignore — Deno APIs used only in lazy-initialized Proxy for build-time manifest generation\n\nimport type {\n  OpenElementAttribute,\n  OpenElementCssPart,\n  OpenElementDeclaration,\n  OpenElementEvent,\n  OpenElementPackageManifest,\n  OpenElementSlot,\n} from '@openelement/protocol/manifest';\n\nconst pkgVersion = '0.40.8';\n\ninterface ComponentMeta {\n  file: string;\n  tagName: string;\n  className: string;\n  description: string;\n  attributes: OpenElementAttribute[];\n  events: OpenElementEvent[];\n  slots: OpenElementSlot[];\n  cssParts: OpenElementCssPart[];\n  layer: 'dsd-static' | 'dsd-interactive';\n  hydrate: 'load' | 'idle' | 'visible';\n}\n\nconst COMPONENT_ORDER = [\n  'open-card',\n  'open-callout',\n  'open-step-card',\n  'open-button',\n  'open-input',\n  'open-theme-toggle',\n  'open-code-block',\n  'open-badge',\n  'open-brand-mark',\n  'open-lab-panel',\n  'open-standards-visual',\n  'open-lab-stage',\n  'open-dialog',\n  'open-layout',\n  'open-dropdown',\n  'open-modal',\n  'open-tabs',\n  'open-hero-ping',\n];\n\nfunction layerFromClass(className: string): ComponentMeta['layer'] {\n  const interactive = new Set([\n    'OpenButton',\n    'OpenInput',\n    'OpenThemeToggle',\n    'OpenDialog',\n    'OpenLayout',\n    'OpenDropdown',\n    'OpenModal',\n    'OpenTabs',\n    'OpenHeroPing',\n  ]);\n  return interactive.has(className) ? 'dsd-interactive' : 'dsd-static';\n}\n\nfunction hydrateFromClass(className: string): ComponentMeta['hydrate'] {\n  const load = new Set([\n    'OpenButton',\n    'OpenInput',\n    'OpenThemeToggle',\n    'OpenLayout',\n    'OpenDropdown',\n    'OpenModal',\n    'OpenTabs',\n  ]);\n  return load.has(className) ? 'load' : 'idle';\n}\n\nfunction inferAttributeType(name: string): string {\n  if (\n    name === 'disabled' || name === 'compact' || name === 'open' || name === 'home' ||\n    name === 'required'\n  ) {\n    return 'boolean';\n  }\n  if (name === 'step') return 'number';\n  if (name === 'nav-items' || name === 'header-nav' || name === 'locales') return 'array';\n  return 'string';\n}\n\nfunction parseObservedAttributes(text: string): string[] {\n  const match = text.match(/static\\s+(?:override\\s+)?observedAttributes\\s*=\\s*\\[([\\s\\S]*?)\\]/);\n  if (!match) return [];\n  return match[1]\n    .split(/,\\s*/)\n    .map((s) => s.trim().replace(/^['\"]|['\"]$/g, ''))\n    .filter(Boolean);\n}\n\nfunction parseTagName(text: string): string {\n  const match = text.match(/export\\s+const\\s+tagName\\s*=\\s*['\"]([^'\"]+)['\"]/);\n  if (!match) throw new Error('Could not find tagName export');\n  return match[1];\n}\n\nfunction parseClassName(text: string, file: string): string {\n  const match = text.match(/export\\s+(?:default\\s+)?class\\s+(\\w+)\\s+extends\\s+OpenElement/);\n  if (!match) throw new Error(`Could not find exported class in ${file}`);\n  return match[1];\n}\n\nfunction parseCssParts(text: string): OpenElementCssPart[] {\n  const parts: OpenElementCssPart[] = [];\n  const seen = new Set<string>();\n  for (const m of text.matchAll(/\\*\\s*@csspart\\s+(\\S+)\\s*-+(.*)/g)) {\n    const name = m[1].trim();\n    const description = m[2].trim();\n    if (!seen.has(name)) {\n      seen.add(name);\n      parts.push({ name, description });\n    }\n  }\n  return parts;\n}\n\nfunction parseSlots(text: string): OpenElementSlot[] {\n  const slots: OpenElementSlot[] = [];\n  const seen = new Set<string>();\n  for (const m of text.matchAll(/\\*\\s*@slot\\s+(\\S*)\\s*-+(.*)/g)) {\n    const name = m[1].trim();\n    const description = m[2].trim();\n    if (!seen.has(name)) {\n      seen.add(name);\n      slots.push({ name, description });\n    }\n  }\n  // Default slot fallback when render includes <slot></slot> but no @slot -\n  if (text.includes('<slot></slot>') || text.includes('<slot ')) {\n    if (!seen.has('')) {\n      slots.unshift({ name: '', description: 'Default slot' });\n    }\n  }\n  return slots;\n}\n\nfunction parseEvents(text: string): OpenElementEvent[] {\n  const events: OpenElementEvent[] = [];\n  const seen = new Set<string>();\n  for (const m of text.matchAll(/new\\s+CustomEvent\\(['\"]([^'\"]+)['\"],?\\s*(?:\\{([^}]*)\\})?/g)) {\n    const name = m[1];\n    if (seen.has(name)) continue;\n    seen.add(name);\n    const detail = (m[2] || '').match(/detail\\s*:\\s*\\{([^}]*)\\}/);\n    events.push({\n      name,\n      type: detail ? `CustomEvent<{ ${detail[1].trim()} }>` : 'CustomEvent',\n      description: `Fired on ${name}`,\n    });\n  }\n  return events;\n}\n\nfunction parseDescription(text: string): string {\n  const lines = text.split('\\n');\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i].trim();\n    if (line.startsWith('* @openelement/ui')) {\n      const next = lines[i + 1]?.replace(/^\\s*\\*\\s?/, '').trim();\n      if (next && !next.startsWith('*') && !next.startsWith('@')) return next;\n    }\n  }\n  return '';\n}\n\nfunction buildMeta(file: string, source: string): ComponentMeta {\n  const tagName = parseTagName(source);\n  const className = parseClassName(source, file);\n  const observed = parseObservedAttributes(source);\n  const attributes: OpenElementAttribute[] = observed.map((name) => ({\n    name,\n    type: inferAttributeType(name),\n    description: `${name} attribute`,\n  }));\n\n  // Provide defaults for known boolean attributes\n  for (const attr of attributes) {\n    if (attr.type === 'boolean') {\n      attr.default = 'false';\n    }\n  }\n\n  return {\n    file,\n    tagName,\n    className,\n    description: parseDescription(source),\n    attributes,\n    events: parseEvents(source),\n    slots: parseSlots(source),\n    cssParts: parseCssParts(source),\n    layer: layerFromClass(className),\n    hydrate: hydrateFromClass(className),\n  };\n}\n\nfunction readComponentSources(): ComponentMeta[] {\n  const dir = new URL('.', import.meta.url);\n  const metas: ComponentMeta[] = [];\n  for (const entry of Deno.readDirSync(dir)) {\n    if (!entry.isFile || !entry.name.startsWith('open-') || !entry.name.endsWith('.tsx')) continue;\n    const file = entry.name;\n    const source = new TextDecoder().decode(Deno.readFileSync(new URL(file, dir)));\n    if (!source.includes('extends OpenElement')) continue;\n    metas.push(buildMeta(file, source));\n  }\n  const order = new Map(COMPONENT_ORDER.map((t, i) => [t, i]));\n  metas.sort((a, b) => (order.get(a.tagName) ?? 999) - (order.get(b.tagName) ?? 999));\n  return metas;\n}\n\nfunction buildDeclaration(meta: ComponentMeta): OpenElementDeclaration {\n  return {\n    tagName: meta.tagName,\n    className: meta.className,\n    superclassName: 'OpenElement',\n    description: meta.description,\n    attributes: meta.attributes.length ? meta.attributes : undefined,\n    events: meta.events.length ? meta.events : undefined,\n    slots: meta.slots.length ? meta.slots : undefined,\n    cssParts: meta.cssParts.length ? meta.cssParts : undefined,\n    openElement: {\n      ssr: true,\n      dsd: true,\n      layer: meta.layer,\n      hydrate: meta.hydrate,\n      module: `@openelement/ui/${meta.file.replace(/\\.tsx$/, '')}`,\n      export: meta.className,\n    },\n  };\n}\n\nfunction buildManifest(): OpenElementPackageManifest {\n  const metas = readComponentSources();\n  const declarations = metas.map(buildDeclaration);\n  const modules = metas.map((meta) => ({\n    path: `./${meta.file.replace(/\\.tsx$/, '.js')}`,\n    exports: [{ name: meta.className, path: `./${meta.file.replace(/\\.tsx$/, '.js')}` }],\n    declarations: [meta.tagName],\n  }));\n\n  return {\n    schemaVersion: '1.0.0',\n    packageName: '@openelement/ui',\n    version: pkgVersion,\n    description: 'Open Props Web Component library for openElement',\n    author: 'openElement',\n    license: 'MIT',\n    homepage: 'https://openelement.org',\n    repository: 'https://github.com/open-element/openelement',\n    openElement: {\n      adapter: 'vanilla',\n      hasStylesheet: true,\n      cssPrefix: 'open',\n    },\n    declarations,\n    modules,\n  };\n}\n\n// ponytail: lazy-initialized to keep Deno runtime calls out of client bundles.\n// buildManifest() scans the filesystem and must only execute at build time.\nlet _manifest: OpenElementPackageManifest | undefined;\nexport const manifest: OpenElementPackageManifest = new Proxy(\n  {} as OpenElementPackageManifest,\n  {\n    get(_target, prop) {\n      if (!_manifest) _manifest = buildManifest();\n      return ((_manifest as unknown) as Record<string, unknown>)[prop as string];\n    },\n    ownKeys() {\n      if (!_manifest) _manifest = buildManifest();\n      return Reflect.ownKeys(_manifest!);\n    },\n    getOwnPropertyDescriptor(_target, prop) {\n      if (!_manifest) _manifest = buildManifest();\n      return Reflect.getOwnPropertyDescriptor(_manifest!, prop);\n    },\n  },\n);\n"],"names":[],"mappings":"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"}

package/src/open-badge.d.ts

@@ -0,0 +1,15 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-badge
+ *
+ * Compact status badge backed by Open Props semantic tokens.
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-badge';
+declare const sheet: StyleSheetLike;
+export declare class OpenBadge extends OpenElement {
+  static override styles: [];
+  static override observedAttributes: [string, string];
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+  private _getStr: any;
+}
+export default OpenBadge;

package/src/open-badge.js

@@ -0,0 +1,88 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-badge
+ *
+ * Compact status badge backed by Open Props semantic tokens.
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+export const tagName = 'open-badge';
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: inline-flex;
+    vertical-align: middle;
+  }
+
+  .badge {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: var(--size-6);
+    padding: var(--badge-padding-y) var(--badge-padding-x);
+    border: var(--border-size-1) solid var(--border);
+    border-radius: var(--badge-radius);
+    background: var(--bg-surface);
+    color: var(--text-secondary);
+    font-family: var(--font-mono);
+    font-size: var(--badge-font-size);
+    font-weight: var(--font-weight-8);
+    line-height: var(--font-lineheight-3);
+    letter-spacing: 0;
+    white-space: nowrap;
+  }
+
+  .badge--brand {
+    border-color: var(--brand);
+    background: var(--brand-subtle);
+    color: var(--brand);
+  }
+
+  .badge--success {
+    border-color: var(--success);
+    background: var(--success-subtle);
+    color: var(--success);
+  }
+
+  .badge--warning {
+    border-color: var(--warning);
+    background: var(--warning-subtle);
+    color: var(--warning);
+  }
+
+  .badge--info {
+    border-color: var(--info);
+    background: var(--info-subtle);
+    color: var(--info);
+  }
+
+  .badge--sm {
+    min-height: var(--size-5);
+    padding-inline: var(--size-2);
+  }
+`);
+export class OpenBadge extends OpenElement {
+  static styles = [
+    sheet
+  ];
+  static observedAttributes = [
+    'tone',
+    'size'
+  ];
+  render() {
+    const tone = this._getStr('tone', 'neutral');
+    const size = this._getStr('size', 'md');
+    return <span className={`badge badge--${tone} badge--${size}`} part='badge'>
+        <slot></slot>
+      </span>;
+  }
+  _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 OpenBadge;
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenBadge);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/open-brand-mark.d.ts

@@ -0,0 +1,14 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-brand-mark
+ *
+ * Flat Aperture O brand mark shared by header, docs surfaces, and assets.
+ */ import { OpenElement } from '@openelement/element';
+import { type StyleSheetLike } from '@openelement/core/style-sheet';
+export declare const tagName: 'open-brand-mark';
+declare const sheet: StyleSheetLike;
+export declare class OpenBrandMark extends OpenElement {
+  static override styles: [];
+  static override observedAttributes: [string, string];
+  override render(): ReturnType<typeof OpenElement.prototype.render>;
+}
+export default OpenBrandMark;