@slotted/react 0.1.0-beta.0 → 0.1.0-beta.10

package/dist/bin/slotted-agent-docs.mjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+/**
+ * Keeps an application's agent material in step with the installed package.
+ *
+ *   slotted-agent-docs instructions write --file <path> [--app-root <dir>] [--theme <name>] [--theme-css <specifier>]
+ *   slotted-agent-docs instructions check --file <path> [same flags]
+ *   slotted-agent-docs skills link --dir <path> [--mode link|copy]
+ *   slotted-agent-docs skills check --dir <path>
+ *
+ * `instructions` writes the package's `AGENTS.snippet.md` into a block of the
+ * named file, between `<!-- slotted:begin version=… -->` and
+ * `<!-- slotted:end -->`; text outside the markers is never touched. `skills`
+ * makes `<dir>/<skill>` for each skill the package ships, as a relative link
+ * or as a copy. Both `check` subcommands exit 1 when the file or the directory
+ * differs from what the matching write would produce.
+ *
+ * The file and the directory are arguments: the command names no agent.
+ */
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  readlinkSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+
+const BEGIN = /<!-- slotted:begin version=\S* -->/;
+const END = '<!-- slotted:end -->';
+const BASE_SENTENCE = 'Paths below are relative to the directory that holds node_modules.';
+
+/** The package that ships this file: the nearest `package.json` named `@slotted/…` above it. */
+function ownPackage() {
+  let dir = dirname(realpathSync(fileURLToPath(import.meta.url)));
+  for (;;) {
+    const manifest = join(dir, 'package.json');
+    if (existsSync(manifest)) {
+      const { name, version } = JSON.parse(readFileSync(manifest, 'utf8'));
+      if (typeof name === 'string' && name.startsWith('@slotted/')) {
+        const docs = ['dist/docs', 'docs'].map((path) => join(dir, path)).find(existsSync);
+        if (docs === undefined) fail(`${name} has no docs directory`);
+        return { name, version, root: dir, docs };
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) fail('no @slotted package above this command');
+    dir = parent;
+  }
+}
+
+function fail(message) {
+  process.stderr.write(`slotted-agent-docs: ${message}\n`);
+  process.exit(2);
+}
+
+/* ── instructions ───────────────────────────────────────────────────────── */
+
+function renderBlock(pkg, { appRoot, theme, themeCss }) {
+  let snippet = readFileSync(join(pkg.docs, 'AGENTS.snippet.md'), 'utf8');
+  if (appRoot !== undefined) {
+    const prefix = appRoot.replaceAll('\\', '/').replace(/\/+$/, '') || '.';
+    snippet = snippet
+      .replace(BASE_SENTENCE, 'Paths below are relative to the directory of this file.')
+      .replaceAll('`node_modules/', `\`${prefix}/node_modules/`);
+  }
+  if (theme !== undefined) {
+    snippet = snippet.replaceAll('data-slotted-theme="default"', `data-slotted-theme="${theme}"`);
+  }
+  if (themeCss !== undefined) {
+    snippet = snippet.replaceAll('`@slotted/themes/default.css`', `\`${themeCss}\``);
+  }
+  if (!snippet.endsWith('\n')) snippet += '\n';
+  return `<!-- slotted:begin version=${pkg.version} -->\n${snippet}${END}`;
+}
+
+/** The file with the block in place: replaced where it stands, or appended. */
+function withBlock(current, block) {
+  const begin = BEGIN.exec(current);
+  if (begin !== null) {
+    const end = current.indexOf(END, begin.index);
+    if (end === -1) fail('a begin marker without an end marker');
+    return current.slice(0, begin.index) + block + current.slice(end + END.length);
+  }
+  if (current === '') return `${block}\n`;
+  return `${current}${current.endsWith('\n') ? '' : '\n'}\n${block}\n`;
+}
+
+/** A unified diff of two texts, by lines, with three lines of context. */
+function unifiedDiff(a, b, from, to) {
+  const x = a.split('\n');
+  const y = b.split('\n');
+  const lcs = Array.from({ length: x.length + 1 }, () => new Array(y.length + 1).fill(0));
+  for (let i = x.length - 1; i >= 0; i--)
+    for (let j = y.length - 1; j >= 0; j--)
+      lcs[i][j] = x[i] === y[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < x.length || j < y.length) {
+    if (i < x.length && j < y.length && x[i] === y[j]) ops.push([' ', x[i++], j++]);
+    else if (j < y.length && (i === x.length || lcs[i][j + 1] >= lcs[i + 1][j]))
+      ops.push(['+', y[j++], i]);
+    else ops.push(['-', x[i++], j]);
+  }
+  const lines = [`--- ${from}`, `+++ ${to}`];
+  let k = 0;
+  while (k < ops.length) {
+    if (ops[k][0] === ' ') {
+      k++;
+      continue;
+    }
+    let start = Math.max(0, k - 3);
+    let stop = k;
+    while (stop < ops.length) {
+      let next = stop;
+      while (next < ops.length && ops[next][0] === ' ') next++;
+      if (next === ops.length || next - stop > 6) break;
+      while (next < ops.length && ops[next][0] !== ' ') next++;
+      stop = next;
+    }
+    stop = Math.min(ops.length, stop + 3);
+    const hunk = ops.slice(start, stop);
+    const oldStart = ops.slice(0, start).filter(([op]) => op !== '+').length + 1;
+    const newStart = ops.slice(0, start).filter(([op]) => op !== '-').length + 1;
+    const oldCount = hunk.filter(([op]) => op !== '+').length;
+    const newCount = hunk.filter(([op]) => op !== '-').length;
+    lines.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+    for (const [op, text] of hunk) lines.push(`${op}${text}`);
+    k = stop;
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function instructions(action, values) {
+  if (values.file === undefined) fail('--file is required');
+  const pkg = ownPackage();
+  const block = renderBlock(pkg, {
+    appRoot: values['app-root'],
+    theme: values.theme,
+    themeCss: values['theme-css'],
+  });
+  const current = existsSync(values.file) ? readFileSync(values.file, 'utf8') : '';
+  const next = withBlock(current, block);
+  if (action === 'write') {
+    if (next !== current) {
+      mkdirSync(dirname(resolve(values.file)), { recursive: true });
+      writeFileSync(values.file, next);
+    }
+    return 0;
+  }
+  if (next === current) return 0;
+  process.stdout.write(unifiedDiff(current, next, values.file, `${values.file} (expected)`));
+  return 1;
+}
+
+/* ── skills ─────────────────────────────────────────────────────────────── */
+
+/**
+ * The skill directories as the application sees them: through its own
+ * `node_modules/<package>`, whose path survives an upgrade, rather than the
+ * store path a package manager may resolve this file to.
+ */
+function installedSkills(pkg) {
+  const docsInPackage = relative(pkg.root, pkg.docs);
+  let base = join(pkg.docs, 'skills');
+  for (let dir = process.cwd(); ; dir = dirname(dir)) {
+    const candidate = join(dir, 'node_modules', ...pkg.name.split('/'), docsInPackage, 'skills');
+    if (existsSync(candidate)) {
+      base = candidate;
+      break;
+    }
+    if (dirname(dir) === dir) break;
+  }
+  const skills = new Map();
+  if (!existsSync(base)) return skills;
+  for (const entry of readdirSync(base, { withFileTypes: true })) {
+    if (entry.isDirectory() && existsSync(join(base, entry.name, 'SKILL.md')))
+      skills.set(entry.name, join(base, entry.name));
+  }
+  return skills;
+}
+
+/** A link this command wrote: one that names the package's skills directory. */
+function isOwnLink(path, pkg) {
+  return readlinkSync(path).split(/[\\/]/).join('/').includes(`${pkg.name}/`);
+}
+
+function sameTree(a, b) {
+  const list = (dir) => readdirSync(dir, { recursive: true, encoding: 'utf8' }).sort();
+  const left = list(a);
+  const right = list(b);
+  if (left.join('\n') !== right.join('\n')) return false;
+  return left.every((file) => {
+    const x = join(a, file);
+    const y = join(b, file);
+    if (statSync(x).isDirectory() || statSync(y).isDirectory())
+      return statSync(x).isDirectory() === statSync(y).isDirectory();
+    return readFileSync(x).equals(readFileSync(y));
+  });
+}
+
+function skillsLink(written, mode, pkg) {
+  const dir = resolve(written);
+  const skills = installedSkills(pkg);
+  if (skills.size === 0) fail(`${pkg.name} ships no skills`);
+  mkdirSync(dir, { recursive: true });
+  for (const [name, source] of skills) {
+    const entry = join(dir, name);
+    const target = relative(dir, source);
+    const stat = existsSync(entry) || isLink(entry) ? lstatSync(entry) : null;
+    if (stat !== null) {
+      if (mode === 'link' && stat.isSymbolicLink() && readlinkSync(entry) === target) continue;
+      if (mode === 'copy' && stat.isDirectory() && sameTree(entry, source)) continue;
+      rmSync(entry, { recursive: true, force: true });
+    }
+    if (mode === 'link') symlinkSync(target, entry, 'dir');
+    else cpSync(source, entry, { recursive: true });
+  }
+  /* A link to a skill the package no longer ships. */
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry);
+    if (!skills.has(entry) && isLink(path) && isOwnLink(path, pkg)) rmSync(path);
+  }
+  return 0;
+}
+
+function isLink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function skillsCheck(dir, pkg) {
+  const skills = installedSkills(pkg);
+  const problems = [];
+  for (const [name, source] of skills) {
+    const entry = join(dir, name);
+    if (isLink(entry)) {
+      if (!existsSync(join(entry, 'SKILL.md'))) problems.push(`${entry}: dangling link`);
+      else if (realpathSync(entry) !== realpathSync(source))
+        problems.push(`${entry}: links to ${readlinkSync(entry)}, not the installed version`);
+    } else if (!existsSync(entry)) problems.push(`${entry}: missing`);
+    else if (!sameTree(entry, source))
+      problems.push(`${entry}: differs from the installed version`);
+  }
+  if (existsSync(dir)) {
+    for (const entry of readdirSync(dir)) {
+      const path = join(dir, entry);
+      if (!skills.has(entry) && isLink(path) && isOwnLink(path, pkg) && !existsSync(path))
+        problems.push(`${path}: dangling link`);
+    }
+  }
+  if (skills.size === 0) problems.push(`${pkg.name}: no installed skills`);
+  for (const problem of problems) process.stdout.write(`${problem.split(sep).join('/')}\n`);
+  return problems.length === 0 ? 0 : 1;
+}
+
+/* ── entry ──────────────────────────────────────────────────────────────── */
+
+const [group, action, ...rest] = process.argv.slice(2);
+const { values } = parseArgs({
+  args: rest,
+  options: {
+    file: { type: 'string' },
+    'app-root': { type: 'string' },
+    theme: { type: 'string' },
+    'theme-css': { type: 'string' },
+    dir: { type: 'string' },
+    mode: { type: 'string', default: 'link' },
+  },
+});
+
+if (group === 'instructions' && (action === 'write' || action === 'check')) {
+  process.exit(instructions(action, values));
+} else if (group === 'skills' && (action === 'link' || action === 'check')) {
+  if (values.dir === undefined) fail('--dir is required');
+  if (values.mode !== 'link' && values.mode !== 'copy') fail('--mode is link or copy');
+  const pkg = ownPackage();
+  process.exit(
+    action === 'link' ? skillsLink(values.dir, values.mode, pkg) : skillsCheck(values.dir, pkg),
+  );
+} else {
+  fail(
+    'usage: slotted-agent-docs instructions write|check --file <path> | skills link|check --dir <path>',
+  );
+}

package/dist/breadcrumb-DCGynpkb.js

@@ -0,0 +1,222 @@
+import { n as e, t } from "./icon-DjqSEQ-o.js";
+import { r as n } from "./i18n-DpW8lqJ1.js";
+import { definedProps as r, keyedProps as i } from "@slotted/core/selector-key";
+import { createControllable as a } from "@slotted/core/state";
+import { Children as o, createContext as s, isValidElement as c, useCallback as l, useContext as u, useEffect as d, useId as f, useLayoutEffect as p, useRef as m, useState as h } from "react";
+import { Fragment as g, jsx as _, jsxs as v } from "react/jsx-runtime";
+import { createCollapse as y } from "@slotted/core/overflow";
+import { breadcrumbMessages as b } from "@slotted/core/i18n";
+//#region src/breadcrumb/breadcrumb-defaults.tsx
+var x = s({});
+function S() {
+	return u(x);
+}
+function C({ children: e, ...t }) {
+	let n = S();
+	return /* @__PURE__ */ _(x.Provider, {
+		value: {
+			itemsAfterCollapse: t.itemsAfterCollapse ?? n.itemsAfterCollapse,
+			itemsBeforeCollapse: t.itemsBeforeCollapse ?? n.itemsBeforeCollapse,
+			maxItems: t.maxItems ?? n.maxItems,
+			overflow: t.overflow ?? n.overflow,
+			separator: t.separator ?? n.separator
+		},
+		children: e
+	});
+}
+//#endregion
+//#region src/breadcrumb/breadcrumb.tsx
+var w = s(void 0), T = s(void 0);
+function E() {
+	let e = u(w);
+	if (e === void 0) throw Error("Breadcrumb parts must be rendered inside a Breadcrumb.");
+	return e;
+}
+function D() {
+	return u(T);
+}
+var O = T.Provider;
+function k({ children: e, defaultExpanded: t, expanded: r, itemsAfterCollapse: o, itemsBeforeCollapse: s, maxItems: c, messages: l, onExpandedChange: u, overflow: p, render: g, separator: v, ...y }) {
+	let x = S(), C = n(b, l), T = f(), [E, D] = h(t ?? !1), [O, k] = h(0), A = r ?? E, j = `slotted-breadcrumb-${T}`, M = m(!1), N = (e, t) => {
+		let n = a({
+			controlled: r,
+			initial: A,
+			onRequest: (e) => u?.(e.value, e)
+		});
+		M.current = !0, n.request(!0, e, t) && D(!0);
+	};
+	d(() => {
+		M.current && A && (M.current = !1, document.getElementById(j)?.focus());
+	}, [A, j]);
+	let P = {
+		expand: N,
+		expanded: A,
+		firstRevealedId: j,
+		itemsAfterCollapse: o ?? x.itemsAfterCollapse ?? 2,
+		itemsBeforeCollapse: s ?? x.itemsBeforeCollapse ?? 1,
+		maxItems: c ?? x.maxItems ?? 8,
+		overflow: p ?? x.overflow ?? "collapse",
+		separator: v ?? x.separator,
+		setCollapsed: k,
+		t: C
+	}, F = i({
+		"aria-label": C("label"),
+		...y,
+		children: e,
+		"data-collapsed": O > 0 ? String(O) : void 0,
+		"data-expanded": A ? "" : void 0,
+		"data-part": "root",
+		"data-ui": "breadcrumb"
+	});
+	return /* @__PURE__ */ _(w.Provider, {
+		value: P,
+		children: g === void 0 ? /* @__PURE__ */ _("nav", { ...F }) : g(F)
+	});
+}
+//#endregion
+//#region src/breadcrumb/breadcrumb-parts.tsx
+function A(e, t, n) {
+	if (!(e <= Math.max(0, t) + Math.max(0, n))) return {
+		start: Math.max(0, t),
+		end: e - Math.max(0, n)
+	};
+}
+function j({ children: e, ref: t, render: n, ...r }) {
+	let a = E(), s = o.toArray(e).filter((e) => c(e)), u = Math.max(0, a.itemsBeforeCollapse), d = Math.max(0, a.itemsAfterCollapse), f = a.maxItems <= 0 || s.length <= a.maxItems ? void 0 : A(s.length, u, d), g = a.expanded ? void 0 : f, v = s.length > u + d, b = a.overflow === "collapse" && !a.expanded && f === void 0 && v, x = m(null), S = m(null), [C, w] = h(0), { setCollapsed: T } = a;
+	p(() => {
+		let e = x.current;
+		if (!b || e === null) {
+			w(0);
+			return;
+		}
+		let t = () => [...e.children].filter((e) => e instanceof HTMLElement && e !== S.current), n = y(e, {
+			collapsible: (e) => {
+				let n = t().indexOf(e);
+				return n >= u && n < t().length - d;
+			},
+			onChange: (e) => w(e.length),
+			rank: (e) => t().indexOf(e),
+			trigger: () => S.current,
+			units: t
+		});
+		return () => {
+			n.destroy(), w(0);
+		};
+	}, [
+		d,
+		u,
+		s.length,
+		b
+	]);
+	let D = g === void 0 ? C : g.end - g.start;
+	p(() => {
+		T(D);
+	}, [D, T]);
+	let k = l((e) => {
+		x.current = e, typeof t == "function" ? t(e) : t != null && (t.current = e);
+	}, [t]), j = [];
+	for (let [e, t] of s.entries()) {
+		e === u && (g !== void 0 || b) && j.push(/* @__PURE__ */ _(N, {
+			hidden: D,
+			idle: g === void 0,
+			itemRef: S
+		}, "slotted-breadcrumb-ellipsis"));
+		let n = g !== void 0 && e >= g.start && e < g.end;
+		j.push(/* @__PURE__ */ _(O, {
+			value: {
+				hidden: n,
+				last: e === s.length - 1,
+				revealedId: v && e === u ? a.firstRevealedId : void 0
+			},
+			children: t
+		}, t.key ?? e));
+	}
+	let M = i({
+		...r,
+		children: j,
+		"data-part": "list",
+		ref: k
+	});
+	return n === void 0 ? /* @__PURE__ */ _("ol", { ...M }) : n(M);
+}
+function M({ children: e }) {
+	return /* @__PURE__ */ _("span", {
+		"aria-hidden": "true",
+		"data-part": "separator",
+		"data-part-separator": "",
+		children: e
+	});
+}
+function N({ hidden: n, idle: r, itemRef: i }) {
+	let a = E();
+	return /* @__PURE__ */ v("li", {
+		"data-part": "item",
+		"data-part-item": "",
+		hidden: r,
+		ref: i,
+		children: [/* @__PURE__ */ _("button", {
+			"aria-expanded": !1,
+			"aria-label": a.t("showHidden", { count: n }),
+			"data-part": "ellipsis",
+			"data-part-ellipsis": "",
+			onClick: (e) => a.expand("pointer", e),
+			onKeyDown: (e) => {
+				(e.key === "Enter" || e.key === " ") && a.expand("keyboard", e);
+			},
+			type: "button",
+			children: /* @__PURE__ */ _(t, { children: /* @__PURE__ */ _(e, { name: "ellipsis" }) })
+		}), /* @__PURE__ */ _(M, { children: a.separator })]
+	});
+}
+function P({ children: e, ref: t, render: n, ...r }) {
+	let a = E(), o = D(), s = i({
+		...r,
+		children: /* @__PURE__ */ v(g, { children: [e, o?.last === !0 ? null : /* @__PURE__ */ _(M, { children: a.separator })] }),
+		"data-part": "item",
+		hidden: o?.hidden === !0 || r.hidden
+	});
+	return n === void 0 ? /* @__PURE__ */ _("li", {
+		...s,
+		ref: t
+	}) : n(s);
+}
+function F({ children: e, ref: t, render: n, ...a }) {
+	let o = D(), s = i({
+		...a,
+		children: e,
+		"data-part": "link",
+		id: a.id ?? o?.revealedId
+	});
+	return n === void 0 ? /* @__PURE__ */ _("a", {
+		...s,
+		ref: t
+	}) : n(r(s));
+}
+function I({ children: n, current: r, ref: a, render: o, ...s }) {
+	let c = D(), l = i({
+		type: "button",
+		...s,
+		"aria-current": r === !0 ? "page" : s["aria-current"],
+		children: /* @__PURE__ */ v(g, { children: [n, /* @__PURE__ */ _(t, { children: /* @__PURE__ */ _(e, { name: "chevron-down" }) })] }),
+		"data-part": "trigger",
+		id: s.id ?? c?.revealedId
+	});
+	return o === void 0 ? /* @__PURE__ */ _("button", {
+		...l,
+		ref: a
+	}) : o(l);
+}
+function L({ children: e, ref: t, render: n, ...r }) {
+	let a = i({
+		...r,
+		"aria-current": "page",
+		children: e,
+		"data-part": "page"
+	});
+	return n === void 0 ? /* @__PURE__ */ _("span", {
+		...a,
+		ref: t
+	}) : n(a);
+}
+//#endregion
+export { I as a, E as c, L as i, C as l, F as n, A as o, j as r, k as s, P as t, S as u };

package/dist/breadcrumb.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "./breadcrumb-Bf01N4wK.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "./breadcrumb-DCGynpkb.js";
 export { s as Breadcrumb, r as BreadcrumbDefaultsProvider, c as BreadcrumbItem, i as BreadcrumbLink, o as BreadcrumbList, n as BreadcrumbPage, e as BreadcrumbTrigger, a as collapsedRange, t as useBreadcrumb, l as useBreadcrumbDefaults };

package/dist/button-BCVjdzkn.js

@@ -0,0 +1,100 @@
+import { r as e } from "./i18n-DpW8lqJ1.js";
+import { a as t, c as n, d as r, f as i, i as a, l as o, o as s, r as c, s as l, u } from "./icon-button-CRB218_z.js";
+import { definedProps as d, keyedProps as f } from "@slotted/core/selector-key";
+import { jsx as p } from "react/jsx-runtime";
+import { buttonMessages as m } from "@slotted/core/i18n";
+//#region src/button/button-link.tsx
+function h({ children: e, disabled: t = !1, end: n, fullWidth: r = !1, href: o, justify: c = "center", onAuxClick: m, onAuxClickCapture: h, onClick: g, onClickCapture: _, onKeyDown: v, onKeyDownCapture: y, render: b, size: x, start: S, tone: C, variant: w, ...T }) {
+	let E = l({
+		size: x,
+		tone: C,
+		variant: w
+	}, u), D = (e) => t ? (a(e), !0) : !1, O = f({
+		...T,
+		...s({
+			disabled: t,
+			fullWidth: r,
+			justify: c,
+			...E
+		}),
+		"aria-disabled": t || void 0,
+		children: /* @__PURE__ */ p(i, {
+			end: n,
+			start: S,
+			children: e
+		}),
+		role: t ? "link" : void 0,
+		tabIndex: t ? T.tabIndex ?? 0 : T.tabIndex,
+		...b === void 0 && !t ? { href: o } : {},
+		onAuxClick: (e) => {
+			D(e) || m?.(e);
+		},
+		onAuxClickCapture: (e) => {
+			D(e) || h?.(e);
+		},
+		onClick: (e) => {
+			D(e) || g?.(e);
+		},
+		onClickCapture: (e) => {
+			D(e) || _?.(e);
+		},
+		onKeyDown: (e) => {
+			e.key === "Enter" && D(e) || v?.(e);
+		},
+		onKeyDownCapture: (e) => {
+			e.key === "Enter" && D(e) || y?.(e);
+		}
+	});
+	return b === void 0 ? /* @__PURE__ */ p("a", { ...O }) : b(d(O));
+}
+//#endregion
+//#region src/button/toggle-button.tsx
+function g({ children: u, defaultPressed: d, disabled: h = !1, end: g, focusableWhenDisabled: _ = !1, fullWidth: v = !1, justify: y = "center", loading: b = !1, loadingDelay: x = 0, messages: S, onClick: C, onClickCapture: w, onPressedChange: T, pressed: E, render: D, size: O, start: k, tone: A, type: j = "button", variant: M, ...N }) {
+	let P = l({
+		size: O,
+		tone: A,
+		variant: M
+	}, r), F = t({
+		disabled: h,
+		focusableWhenDisabled: _,
+		loading: b
+	}), I = n({
+		loading: b,
+		loadingDelay: x
+	}), L = e(m, S), R = o({
+		defaultPressed: d,
+		onPressedChange: T,
+		pressed: E
+	}), z = f({
+		...N,
+		...s({
+			disabled: h,
+			fullWidth: v,
+			justify: y,
+			loading: b,
+			pressed: R.pressed,
+			...P
+		}),
+		"aria-disabled": F.ariaDisabled,
+		"aria-pressed": R.pressed,
+		children: /* @__PURE__ */ p(i, {
+			end: g,
+			indicator: I ? /* @__PURE__ */ p(c, { label: L("loading") }) : null,
+			start: k,
+			children: u
+		}),
+		disabled: F.nativelyDisabled,
+		onClick: (e) => {
+			if (F.refuses) return a(e);
+			C?.(e), e.defaultPrevented || R.requestToggle(e);
+		},
+		onClickCapture: (e) => {
+			if (F.refuses) return a(e);
+			w?.(e);
+		},
+		type: j
+	});
+	return D === void 0 ? /* @__PURE__ */ p("button", { ...z }) : D(z);
+}
+//#endregion
+export { h as n, g as t };

package/dist/button-group-C-m4aSqu.js

@@ -0,0 +1,51 @@
+import { t as e } from "./button-defaults-DNq_DDJh.js";
+import { keyedProps as t } from "@slotted/core/selector-key";
+import { createContext as n, useContext as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/button-group/button-group-shape.tsx
+var a = n({ orientation: "horizontal" }), o = a.Provider;
+function s() {
+	return r(a);
+}
+//#endregion
+//#region src/button-group/button-group.tsx
+function c({ align: n, children: r, fullWidth: a, justify: s, orientation: c, render: l, size: u, tone: d, variant: f, ...p }) {
+	let m = /* @__PURE__ */ i(o, {
+		value: { orientation: c ?? "horizontal" },
+		children: u !== void 0 || d !== void 0 || f !== void 0 ? /* @__PURE__ */ i(e, {
+			size: u,
+			tone: d,
+			variant: f,
+			children: r
+		}) : r
+	}), h = t({
+		role: "group",
+		...p,
+		...n === void 0 ? {} : { "data-align": n },
+		...s === void 0 ? {} : { "data-justify": s },
+		...c === void 0 ? {} : { "data-orientation": c },
+		...a ? { "data-full-width": "" } : {},
+		"data-part": "root",
+		"data-ui": "button-group",
+		children: m
+	});
+	return l === void 0 ? /* @__PURE__ */ i("div", { ...h }) : l(h);
+}
+//#endregion
+//#region src/button-group/button-group-separator.tsx
+function l({ decorative: e = !1, render: n, ...r }) {
+	let { orientation: a } = s(), o = t({
+		...e ? {
+			"aria-hidden": !0,
+			role: "none"
+		} : {
+			role: "separator",
+			"aria-orientation": a === "vertical" ? "horizontal" : "vertical"
+		},
+		...r,
+		"data-part": "separator"
+	});
+	return n === void 0 ? /* @__PURE__ */ i("div", { ...o }) : n(o);
+}
+//#endregion
+export { c as n, l as t };

package/dist/button-group.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./button-group-Det_nYor.js";
+import { n as e, t } from "./button-group-C-m4aSqu.js";
 export { e as ButtonGroup, t as ButtonGroupSeparator };

package/dist/button.js

@@ -1,4 +1,4 @@
 import { n as e, t } from "./button-defaults-DNq_DDJh.js";
-import { n, t as r } from "./icon-button-TnvMhK4o.js";
-import { n as i, t as a } from "./button-DakQ-7Tm.js";
+import { n, t as r } from "./icon-button-CRB218_z.js";
+import { n as i, t as a } from "./button-BCVjdzkn.js";
 export { n as Button, t as ButtonDefaultsProvider, i as ButtonLink, r as IconButton, a as ToggleButton, e as useButtonDefaults };