@stacksjs/components 0.2.571 → 0.2.573

package/dist/ui/sidebar/SidebarSpaces.d.ts

@@ -0,0 +1,38 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+// Arc's swipeable spaces.
+//
+// Every space is rendered up front, side by side on one track that is
+// `n × 100%` wide; switching is a transform on the track rather than a
+// re-render. That is what makes the gesture feel native — the next space is
+// already painted, so it tracks the finger at 1:1 instead of appearing after
+// the gesture ends. It also means each space keeps its own scroll position,
+// its own disclosure state and its own DOM, exactly like Arc.
+export declare const spaceList: unknown;
+export declare const theme: unknown;
+// `space` names the space to open on. `active` is accepted as an alias so the
+// prop reads naturally next to `<SidebarSpaceSwitcher :active>`.
+export declare const activeId: unknown;
+export declare const activeIndex: unknown;
+export declare const showSwitcher: unknown;
+export declare const showAdd: ReturnType<typeof $bool>;
+export declare const addLabel: unknown;
+export declare const persistKey: unknown;
+// One panel is `100 / n` percent of the track, so the server-rendered
+// transform matches exactly what the controller computes on the client and the
+// track does not jump on hydration.
+declare const panelCount: unknown;
+export declare const trackWidth: unknown;
+export declare const initialShift: unknown;
+// Everything the controller needs, in one attribute.
+//
+// It travels as data rather than as interpolated constants in the client
+// script on purpose: `<script client>` blocks are bundled and cached by
+// content, so baking per-instance values into one would either bust that cache
+// on every render or — worse, once a bundle is reused — hand a second sidebar
+// the first one's configuration. Rows and sections are already in the DOM, so
+// only each space's identity and palette have to ship here; those are what a
+// swipe repaints.
+export declare const config: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ spaces?: unknown[], theme?: string, space?: unknown, active?: unknown, showSwitcher?: unknown, showAdd?: unknown, addLabel?: string, persistKey?: string }>;
+export default __dtsx_component__;

package/dist/ui/sidebar/index.d.ts

@@ -83,15 +83,15 @@ export declare interface SidebarFooterProps {
 declare type MacOSSidebarTheme = 'macos' | 'macos-tahoe' | 'macos-latest' | 'tahoe';
 declare type LegacySidebarTheme = 'vibrancy' | 'solid' | 'transparent' | 'workspace' | 'desktop';
 export type SidebarThemeChoice = MacOSSidebarTheme | LegacySidebarTheme;
-export { default as Sidebar } from './Sidebar.stx';
-export { default as SidebarFooter } from './SidebarFooter.stx';
-export { default as SidebarHeader } from './SidebarHeader.stx';
-export { default as SidebarItem } from './SidebarItem.stx';
-export { default as SidebarPinned } from './SidebarPinned.stx';
-export { default as SidebarSection } from './SidebarSection.stx';
-export { default as SidebarSpace } from './SidebarSpace.stx';
-export { default as SidebarSpaces } from './SidebarSpaces.stx';
-export { default as SidebarSpaceSwitcher } from './SidebarSpaceSwitcher.stx';
+export { default as Sidebar } from './Sidebar';
+export { default as SidebarFooter } from './SidebarFooter';
+export { default as SidebarHeader } from './SidebarHeader';
+export { default as SidebarItem } from './SidebarItem';
+export { default as SidebarPinned } from './SidebarPinned';
+export { default as SidebarSection } from './SidebarSection';
+export { default as SidebarSpace } from './SidebarSpace';
+export { default as SidebarSpaces } from './SidebarSpaces';
+export { default as SidebarSpaceSwitcher } from './SidebarSpaceSwitcher';
 export * from './rows';
 export * from './spaces';
 export * from './themes';

package/dist/ui/sidebar/themes.d.ts

@@ -54,11 +54,45 @@ export declare const macosColors: {
   brown: '#ac7f5e';
   gray: '#8e8e93'
 };
-export declare const sidebarThemes: {
-  'tahoe': unknown;
-  'macos-tahoe': unknown;
-  'macos-latest': unknown
-};
+declare const macos: SidebarTheme;
+/**
+ * Legacy themes carried over from the old per-component variant maps so
+ * existing apps keep rendering identically. New work should use `macos`.
+ */
+declare const workspace: SidebarTheme;
+declare const desktop: SidebarTheme;
+/**
+ * `arc` — the Arc browser sidebar.
+ *
+ * Where macOS paints the selected row with the system accent, Arc raises it:
+ * the active row becomes a white card floating on a warm tinted panel, with a
+ * hairline border and a single-pixel drop shadow. That inversion — light card
+ * on tinted ground, rather than saturated fill on gray — is the whole look, so
+ * this theme uses the `classes` selection model and puts the card in
+ * `item.active` instead of the accent rules the `accent` model applies.
+ *
+ * Metrics taken from Arc 1.5x at @2x:
+ *
+ *   row pitch 30px with 2px between rows — rows are separate cards, not the
+ *     contiguous run AppKit uses, so consecutive selections read as distinct
+ *   selection radius 8px · white fill · 1px hairline · shadow 0 1px 2px/8%
+ *   label 13px, and the selected row goes to 500 (not 600 — Arc keeps the
+ *     weight shift subtle because the card already carries the emphasis)
+ *   section header 11px medium, sentence case, 55% muted
+ *   icon 16px in an 18px slot · child indent 14px
+ *   panel warm off-white (#f7f5f1), noticeably warmer than macOS's neutral
+ *     #f2f2f4 — the warmth is what makes it read as Arc at a glance
+ *
+ * The panel tint is a soft top-down gradient rather than a flat fill, which is
+ * how Arc suggests the current space's color. Apps that want a per-space tint
+ * can override `--stx-sidebar-tint` on the pane; the gradient falls back to the
+ * warm default when it is unset.
+ */
+declare const arc: SidebarTheme;
+declare const solid: SidebarTheme;
+declare const transparent: SidebarTheme;
+declare const vibrancy: SidebarTheme;
+export declare const sidebarThemes: Record<string, SidebarTheme>;
 /** Class groups a sidebar theme provides. All values are utility classes. */
 export declare interface SidebarTheme {
   pane: string

package/dist/ui/skeleton/Skeleton.d.ts

@@ -0,0 +1,13 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const variant: unknown;
+export declare const count: unknown;
+export declare const width: unknown;
+export declare const height: unknown;
+export declare const circle: ReturnType<typeof $bool>;
+export declare const className: unknown;
+export declare const animate: unknown;
+export declare const skeletonClasses: unknown;
+export declare const containerClasses: boolean;
+declare type __DtsxStxComponentType = DefineComponent<{ variant?: string, count?: unknown, width?: string, height?: string, circle?: unknown, className?: string, animate?: unknown }>;
+export default __dtsx_component__;

package/dist/ui/skeleton/index.d.ts

@@ -7,4 +7,4 @@ export declare interface SkeletonProps {
   animate?: boolean
   className?: string
 }
-export { default as Skeleton } from './Skeleton.stx';
+export { default as Skeleton } from './Skeleton';

package/dist/ui/spinner/Spinner.d.ts

@@ -0,0 +1,13 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const variant: unknown;
+export declare const size: unknown;
+export declare const color: unknown;
+export declare const label: unknown;
+export declare const className: unknown;
+export declare const containerClasses: unknown;
+export declare const spinnerClasses: unknown;
+export declare const labelClasses: unknown;
+export declare const dotClasses: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ variant?: string, size?: string, color?: string, label?: string, className?: string }>;
+export default __dtsx_component__;

package/dist/ui/spinner/index.d.ts

@@ -5,4 +5,4 @@ export declare interface SpinnerProps {
   label?: string
   className?: string
 }
-export { default as Spinner } from './Spinner.stx';
+export { default as Spinner } from './Spinner';

package/dist/ui/stepper/Stepper.d.ts

@@ -0,0 +1,8 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const currentStep: unknown;
+export declare const orientation: unknown;
+export declare const className: unknown;
+export declare const as: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ currentStep?: unknown, orientation?: string, className?: string, as?: string }>;
+export default __dtsx_component__;

package/dist/ui/stepper/StepperStep.d.ts

@@ -0,0 +1,17 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+// Defaulted, and not only for tidiness: this value is spliced into the client
+// script below as `const stepNumber = {{ stepNumber }}`. An undefined server
+// value leaves the mustache in the JavaScript, which is a SyntaxError that
+// takes the whole scoped script down -- onClick included. `??` rather than
+// `||` so an explicit 0 (the first step) survives.
+export declare const stepNumber: unknown;
+export declare const currentStep: unknown;
+export declare const label: unknown;
+export declare const description: unknown;
+export declare const className: unknown;
+export declare const as: unknown;
+export declare const isComplete: boolean;
+export declare const stepClasses: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ stepNumber?: unknown, currentStep?: unknown, label?: string, description?: string, className?: string, as?: string }>;
+export default __dtsx_component__;

package/dist/ui/stepper/index.d.ts

@@ -13,5 +13,5 @@ export declare interface StepperStepProps {
   as?: string
   onClick?: (step: number) => void
 }
-export { default as Stepper } from './Stepper.stx';
-export { default as StepperStep } from './StepperStep.stx';
+export { default as Stepper } from './Stepper';
+export { default as StepperStep } from './StepperStep';

package/dist/ui/switch/Switch.d.ts

@@ -0,0 +1,75 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare function toggle(): undefined;
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const checked: ReturnType<typeof $bool>;
+/*
+ * Form participation, which a <button role="switch"> cannot have on its own
+ * (stacksjs/stx#2043).
+ *
+ * The control the user operates is a button, and a button is never submitted
+ * by name -- so a Switch inside a form contributed nothing to FormData no
+ * matter what it was set to. A hidden input carries the state instead, which
+ * is what it takes for a custom switch to be readable the way a checkbox is.
+ *
+ * Only rendered when a `name` is given, so a Switch used as a plain toggle
+ * emits exactly the markup it did before.
+ */
+export declare const name: unknown;
+export declare const form: unknown;
+export declare const checkedValue: unknown;
+export declare const uncheckedValue: unknown;
+export declare const disabled: ReturnType<typeof $bool>;
+export declare const size: unknown;
+export declare const className: unknown;
+export declare const label: unknown;
+/**
+ * @defaultValue
+ * ```ts
+ * {
+ *   sm: { track: 'h-5 w-9', thumb: 'h-4 w-4', translate: 'translate-x-4' },
+ *   md: {
+ *     track: 'h-[38px] w-[74px]',
+ *     thumb: 'h-[34px] w-[34px]',
+ *     translate: 'translate-x-9'
+ *   },
+ *   lg: { track: 'h-12 w-24', thumb: 'h-11 w-11', translate: 'translate-x-12' }
+ * }
+ * ```
+ */
+declare const sizeConfig: {
+  sm: {
+  /** @defaultValue 'h-5 w-9' */
+  track: string;
+  /** @defaultValue 'h-4 w-4' */
+  thumb: string;
+  /** @defaultValue 'translate-x-4' */
+  translate: string
+};
+  md: {
+  /** @defaultValue 'h-[38px] w-[74px]' */
+  track: string;
+  /** @defaultValue 'h-[34px] w-[34px]' */
+  thumb: string;
+  /** @defaultValue 'translate-x-9' */
+  translate: string
+};
+  lg: {
+  /** @defaultValue 'h-12 w-24' */
+  track: string;
+  /** @defaultValue 'h-11 w-11' */
+  thumb: string;
+  /** @defaultValue 'translate-x-12' */
+  translate: string
+}
+};
+// Falls back rather than indexing to undefined: `size="huge"` is a typo, and
+// without this it became `const config = {{ config }}` in the client script --
+// a SyntaxError that killed the whole component rather than mis-sizing it.
+export declare const config: unknown;
+export declare const trackBaseClasses: 'relative inline-flex shrink-0 cursor-pointer border-2 border-transparent rounded-full transition-colors duration-200 ease-in-out focus:outline-none focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2 focus-visible:ring-offset-panel';
+export declare const trackDisabledClasses: unknown;
+export declare const thumbBaseClasses: 'pointer-events-none inline-block transform rounded-full bg-white shadow-lg ring-0 transition duration-200 ease-in-out';
+// v-model:checked adds two-way binding; keep @change for existing callers.
+declare const isChecked: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ checked?: unknown, name?: string, form?: string, checkedValue?: string, uncheckedValue?: string, disabled?: unknown, size?: string, className?: string, label?: string }> & { readonly __stxExposed?: { isChecked: typeof isChecked, toggle: typeof toggle } }
+export default __dtsx_component__;

package/dist/ui/switch/index.d.ts

@@ -6,4 +6,4 @@ export declare interface SwitchProps {
   onChange?: (checked: boolean) => void
   label?: string
 }
-export { default as Switch } from './Switch.stx';
+export { default as Switch } from './Switch';

package/dist/ui/table/Table.d.ts

@@ -0,0 +1,20 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const className: unknown;
+export declare const striped: ReturnType<typeof $bool>;
+export declare const hoverable: unknown;
+/*
+ * The table's accessible name (stacksjs/stx#2060).
+ *
+ * A table is named by its <caption>, and there was no way to give a library
+ * table one: no prop, and no slot ahead of <thead>. It is the table's first
+ * child, as HTML requires, and visually hidden unless `captionVisible` -- most
+ * tables sit under a heading that already says what they are, and a second
+ * visible title would repeat it.
+ */
+export declare const caption: unknown;
+export declare const captionVisible: ReturnType<typeof $bool>;
+export declare const captionClasses: unknown;
+export declare const tableClasses: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ className?: string, striped?: unknown, hoverable?: unknown, caption?: string, captionVisible?: unknown }>;
+export default __dtsx_component__;

package/dist/ui/table/TableBody.d.ts

@@ -0,0 +1,5 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const className: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ className?: string }>;
+export default __dtsx_component__;

package/dist/ui/table/TableCell.d.ts

@@ -0,0 +1,5 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const className: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ className?: string }>;
+export default __dtsx_component__;

package/dist/ui/table/TableHead.d.ts

@@ -0,0 +1,5 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const className: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ className?: string }>;
+export default __dtsx_component__;

package/dist/ui/table/TableHeader.d.ts

@@ -0,0 +1,45 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const className: unknown;
+export declare const sortable: ReturnType<typeof $bool>;
+/*
+ * Which cells this header heads (stacksjs/stx#2060).
+ *
+ * A <th> without `scope` leaves a screen reader to guess, and it guesses wrong
+ * in any table with row headers. `col` by default, because that is what a
+ * header in a <thead> is; `row` for a header at the start of a body row. An
+ * attribute written on <TableHeader> never reached the <th>, so there was no
+ * way to say it at all.
+ * @defaultValue `['col', 'row', 'colgroup', 'rowgroup']`
+ */
+declare const SCOPES: string[];
+export declare const scope: unknown;
+/*
+ * Which way the column is sorted now, as `aria-sort` on the <th> -- the one
+ * place a screen reader looks for it. `asc` / `desc`; anything else is
+ * unsorted, `none`. Served on every sortable header (and on any header given
+ * a `sort`), and live, so a page re-sorting a table moves it without a
+ * re-render.
+ * @defaultValue `{ asc: 'ascending', desc: 'descending' }`
+ */
+declare const SORTS: {
+  /** @defaultValue 'ascending' */
+  asc: string;
+  /** @defaultValue 'descending' */
+  desc: string
+};
+export declare const sortDirection: unknown;
+export declare const announcesSort: unknown;
+export declare const servedAriaSort: unknown;
+export declare const headerClasses: unknown;
+/*
+ * The control that sorts. A <th> is not focusable, so a click handler on it
+ * made sorting mouse-only (stacksjs/stx#2060); a <button> inside it is
+ * reachable by Tab and operated by Enter and Space, and it is what emits
+ * `click`. It takes on the header's type -- the preflight resets a button's
+ * text-transform, so `uppercase` is restated -- and draws a ring on keyboard
+ * focus only.
+ */
+export declare const buttonClasses: 'inline-flex items-center gap-1 uppercase tracking-wider text-left rounded-control cursor-pointer hover:text-fg-strong focus:outline-none focus-visible:ring-2 focus-visible:ring-accent';
+declare type __DtsxStxComponentType = DefineComponent<{ className?: string, sortable?: unknown, scope?: unknown, sort?: unknown }>;
+export default __dtsx_component__;

package/dist/ui/table/TableRow.d.ts

@@ -0,0 +1,6 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const className: unknown;
+export declare const hoverable: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ className?: string, hoverable?: unknown }>;
+export default __dtsx_component__;

package/dist/ui/table/index.d.ts

@@ -25,9 +25,9 @@ export declare interface TableHeaderProps {
 export declare interface TableCellProps {
   className?: string
 }
-export { default as Table } from './Table.stx';
-export { default as TableBody } from './TableBody.stx';
-export { default as TableCell } from './TableCell.stx';
-export { default as TableHead } from './TableHead.stx';
-export { default as TableHeader } from './TableHeader.stx';
-export { default as TableRow } from './TableRow.stx';
+export { default as Table } from './Table';
+export { default as TableBody } from './TableBody';
+export { default as TableCell } from './TableCell';
+export { default as TableHead } from './TableHead';
+export { default as TableHeader } from './TableHeader';
+export { default as TableRow } from './TableRow';

package/dist/ui/tabs/Tab.d.ts

@@ -0,0 +1,19 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+/*
+ * One tab in a <TabList>. A plain button with the role, its value and the
+ * panel it controls; the list keeps `aria-selected` and `tabindex` on it.
+ *
+ * No client script, so no scope of its own: it is a button in the strip,
+ * nothing around it, and `@click` or bound attributes written on it land on
+ * the button in the caller's scope. Style the selected state with
+ * `aria-selected:` utilities, which outrank the base classes.
+ */
+export declare const value: unknown;
+export declare const controls: unknown;
+export declare const disabled: ReturnType<typeof $bool>;
+export declare const variant: unknown;
+export declare const className: unknown;
+export declare const tabClasses: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ value?: string, controls?: string, disabled?: unknown, variant?: string, className?: string }>;
+export default __dtsx_component__;

package/dist/ui/tabs/TabList.d.ts

@@ -0,0 +1,34 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+/*
+ * A tab strip whose selection and panels belong to the page (stacksjs/stx#2058).
+ *
+ * <Tabs> owns both its selection and its panels: it renders every panel inside
+ * itself and remembers the tab it was told to start on. That suits a settings
+ * card. It does not suit tabs that switch between whole sections of a page,
+ * where the selection is kept in the URL or a store and each section is behind
+ * its own `:if`, so a section nobody opened never fetches its data.
+ *
+ * TabList is the behaviour alone. Its children are `role="tab"` elements, a
+ * `<Tab>` or any element with `role="tab"` and `data-value` (a `:for` row
+ * works), and it gives them what the role promises: one tab stop on the
+ * selected tab, the arrow keys, Home and End moving between them and selecting
+ * as they go, and `aria-selected` kept true on exactly one. The selection is a
+ * `v-model:value`, or `:value` with `@change`.
+ *
+ *   <TabList v-model:value="tab" label="Store sections" variant="line">
+ *     <Tab value="products" controls="products-panel">Products</Tab>
+ *     <Tab value="sales" controls="sales-panel">Sales</Tab>
+ *   </TabList>
+ *   <section :if="tab === 'products'" id="products-panel" role="tabpanel">…</section>
+ */
+export declare const value: unknown;
+export declare const label: unknown;
+export declare const labelledby: unknown;
+export declare const orientation: boolean;
+export declare const variant: unknown;
+export declare const className: unknown;
+export declare const listClasses: unknown;
+declare const selected: ReturnType<typeof useModel>;
+declare type __DtsxStxComponentType = DefineComponent<{ value?: string, label?: string, labelledby?: string, orientation?: unknown, variant?: string, className?: string }> & { readonly __stxExposed?: { selected: typeof selected } }
+export default __dtsx_component__;

package/dist/ui/tabs/TabPanel.d.ts

@@ -0,0 +1,13 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+// Slot wrapper that the parent <Tabs> discovers via DOM walk. The parent
+// reads `data-label` (and optional `data-icon`) to build the tab list and
+// toggles the `hidden` attribute as the active tab changes. Hidden by
+// default — the parent flips the active one visible after mount. See
+// stacksjs/stx#1703.
+export declare const label: unknown;
+export declare const icon: unknown;
+export declare const className: unknown;
+export declare const panelClasses: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ label?: string, icon?: string, className?: string }>;
+export default __dtsx_component__;

package/dist/ui/tabs/Tabs.d.ts

@@ -0,0 +1,30 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare function selectTab(index: unknown): void;
+declare const __dtsx_component__: __DtsxStxComponentType;
+// Two modes (see stacksjs/stx#1703):
+//   1. Legacy prop API — pass `tabs={[{label, content, icon}, …]}` for
+//      simple string-content tabs (kept for backward compatibility with
+//      existing visual snapshots and consumers).
+//   2. Slot API — drop `<TabPanel label="…">` children for arbitrary
+//      content (components, forms, tables, etc.). The parent enumerates
+//      [data-stx-tab-panel] descendants on mount and builds the tab list
+//      dynamically.
+export declare const tabs: unknown;
+export declare const defaultTab: unknown;
+export declare const orientation: unknown;
+export declare const variant: unknown;
+export declare const className: unknown;
+/*
+ * This tab set's own id, so the ids it mints for slot-mode tabs and panels
+ * cannot collide with a second <Tabs> on the same page. Same idiom as Dialog.
+ */
+export declare const tabsInstanceId: unknown;
+export declare const containerClasses: unknown;
+export declare const tabListClasses: unknown;
+export declare const tabPanelClasses: unknown;
+// True when the parent passes a non-empty `tabs` array — switches to the
+// legacy render path so existing snapshots stay byte-identical.
+export declare const hasPropTabs: boolean;
+declare const activeTab: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ tabs?: unknown[], defaultTab?: unknown, orientation?: string, variant?: string, className?: string }> & { readonly __stxExposed?: { activeTab: typeof activeTab, selectTab: typeof selectTab } }
+export default __dtsx_component__;

package/dist/ui/tabs/index.d.ts

@@ -71,7 +71,7 @@ export declare interface TabProps {
   variant?: 'line' | 'pills' | 'none'
   className?: string
 }
-export { default as Tab } from './Tab.stx';
-export { default as TabList } from './TabList.stx';
-export { default as TabPanel } from './TabPanel.stx';
-export { default as Tabs } from './Tabs.stx';
+export { default as Tab } from './Tab';
+export { default as TabList } from './TabList';
+export { default as TabPanel } from './TabPanel';
+export { default as Tabs } from './Tabs';

package/dist/ui/teleport/Teleport.d.ts

@@ -0,0 +1,8 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const to: unknown;
+export declare const disabled: ReturnType<typeof $bool>;
+export declare const defer: ReturnType<typeof $bool>;
+export declare const teleportId: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ to?: string, disabled?: unknown, defer?: unknown }>;
+export default __dtsx_component__;

package/dist/ui/teleport/index.d.ts

@@ -3,4 +3,4 @@ export declare interface TeleportProps {
   disabled?: boolean
   defer?: boolean
 }
-export { default as Teleport } from './Teleport.stx';
+export { default as Teleport } from './Teleport';

package/dist/ui/textarea/Textarea.d.ts

@@ -0,0 +1,75 @@
+import type { DefineComponent } from '@stacksjs/stx';
+declare const __dtsx_component__: __DtsxStxComponentType;
+export declare const value: unknown;
+export declare const placeholder: unknown;
+export declare const disabled: ReturnType<typeof $bool>;
+export declare const readonly: ReturnType<typeof $bool>;
+export declare const rows: unknown;
+export declare const autoResize: ReturnType<typeof $bool>;
+export declare const maxRows: unknown;
+export declare const error: ReturnType<typeof $bool>;
+export declare const label: unknown;
+/*
+ * Ids unique to this instance.
+ *
+ * These were derived from the LABEL or hardcoded outright, so two of these on
+ * one page -- an ordinary form -- emitted the same id twice. `<label for>`
+ * then activated the FIRST field from every label, and `aria-describedby`
+ * pointed every field's description at the first one's helper text. A label
+ * containing a space also produced an invalid id, `input-First name`, which
+ * getElementById and querySelector cannot address at all.
+ *
+ * `$uid` is unique per instance and stable across renders, which is what an id
+ * has to be (utils.ts explains why a render that changes its own bytes is
+ * uncacheable). The `id` prop overrides it, for a caller that needs to point
+ * its own `for` or `aria-describedby` at this control.
+ */
+export declare const inputId: unknown;
+export declare const helperId: string;
+export declare const helperText: unknown;
+export declare const required: ReturnType<typeof $bool>;
+export declare const maxLength: unknown;
+export declare const showCount: ReturnType<typeof $bool>;
+export declare const resize: unknown;
+export declare const className: unknown;
+/*
+ * The padding and type read the density roles, so an
+ * app sets its own field size with --stx-control-px, --stx-control-py,
+ * --stx-control-text and --stx-control-leading instead of a className
+ * that ties with py-2 on specificity. The fallbacks are px-4 / py-2 /
+ * text-base, so nothing moves by default (stacksjs/stx#1993).
+ */
+/*
+ * The two halves of the validity state, exported so the CLIENT can swap them
+ * (stacksjs/stx#2047). Toggled per class rather than as a whole string,
+ * because a reactive class string MERGES with the static one and the element
+ * would carry both rings at once.
+ */
+export declare const stateInvalidClasses: 'ring-danger-line text-danger-fg placeholder-danger focus:ring-danger-focus';
+export declare const stateValidClasses: 'ring-line-strong text-fg placeholder-fg-soft focus:ring-accent';
+export declare const textareaClasses: unknown;
+export declare const labelClasses: unknown;
+export declare const helperClasses: unknown;
+/*
+ * The attributes that make this a form control (stacksjs/stx#2043).
+ *
+ * A control with no `name` is not a form control in the HTML sense: it is left
+ * out of FormData, out of form.elements.namedItem(), and out of an ordinary
+ * non-JS POST. A form built from these components submitted nothing for every
+ * field, silently -- which is how six apps read their forms.
+ *
+ * `autocomplete` is separate and just as load-bearing: it is how the browser
+ * and a password manager identify a field, so a password input without
+ * `autocomplete="current-password"` is never offered for autofill and is not
+ * recognised as part of a sign-in form at all.
+ *
+ * Emitted only when given, so a control that passes none of them renders
+ * exactly the markup it did before.
+ */
+export declare const name: unknown;
+export declare const autocomplete: unknown;
+export declare const form: unknown;
+export declare const inputMode: unknown;
+export declare const enterKeyHint: unknown;
+declare type __DtsxStxComponentType = DefineComponent<{ value?: string, placeholder?: string, disabled?: unknown, readonly?: unknown, rows?: unknown, autoResize?: unknown, maxRows?: unknown, error?: unknown, label?: string, id?: string, helperText?: string, required?: unknown, maxLength?: unknown, showCount?: unknown, resize?: string, className?: string, name?: string, autocomplete?: unknown, autoComplete?: string, form?: string, inputMode?: unknown, inputmode?: string, enterKeyHint?: unknown, enterkeyhint?: string }> & { readonly __stxExposed?: { value: unknown } }
+export default __dtsx_component__;

package/dist/ui/textarea/index.d.ts

@@ -16,4 +16,4 @@ export declare interface TextareaProps {
   resize?: 'none' | 'vertical' | 'horizontal' | 'both'
   className?: string
 }
-export { default as Textarea } from './Textarea.stx';
+export { default as Textarea } from './Textarea';