ropav 0.2.0 → 0.3.0

package/LICENSE

@@ -1,21 +1,199 @@
-MIT License
-
-Copyright (c) 2026 daopk
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. Please also get an approval
+      from the project maintainers before using the Apache License.
+
+   Copyright 2025 NextUI Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,161 +1,34 @@
 # Ropav
 
-Minimal UI components for Vue Vapor.
+A Vue 3 component library built on [Vue Vapor](https://github.com/vuejs/core-vapor), styled by
+[`@ropav/styles`](packages/styles) and Tailwind CSS v4. Published on npm as
+[`ropav`](https://www.npmjs.com/package/ropav).
 
-Ropav components require Vapor mode. Use `createVaporApp`, or install Vue's
-Vapor interop plugin in a regular app.
+> Ropav is a port of [HeroUI v3](https://github.com/heroui-inc/heroui) to Vue Vapor: the style layer is
+> vendored from `@heroui/styles@3.2.4`, the behaviour layer is re-implemented from React Aria.
 
-```ts
-import { createVaporApp } from 'vue';
+## Packages
 
-createVaporApp(App).mount('#app');
-```
-
-or
-
-```ts
-import { createApp, vaporInteropPlugin } from 'vue';
-
-createApp(App).use(vaporInteropPlugin).mount('#app');
-```
-
-## Install
-
-```bash
-pnpm add ropav
-```
-
-## Setup
-
-```ts
-import 'ropav/base.css';
-```
-
-Import the components you need:
-
-```ts
-import { Button } from 'ropav';
-```
-
-Headless state utilities are available from `ropav/composables`. See the
-[public composables API](./docs/public-composables-api.md) for their controlled and uncontrolled
-state contracts.
-
-## Custom color contrast
-
-`autoContrast` selects foreground colors for preset colors and opaque custom color literals. A
-translucent custom color depends on the surface behind the component, so its contrast cannot be
-determined from the color alone. Pass `contrastColor` explicitly whenever a custom background has
-alpha:
-
-```vue
-<Button color="rgba(255, 255, 255, 0.2)" contrast-color="var(--rp-color-white)" variant="solid">
-  Continue
-</Button>
-```
-
-In development, Ropav warns when auto contrast receives a translucent custom color without an
-explicit `contrastColor`. The production fallback remains `var(--rp-color-white)`.
-
-## Progress and interactive ranges
-
-Use `Progress` for read-only status and `Slider` when the user can change the value. A media seek
-control can draw buffered ranges below the played range, reveal its thumb during interaction, and
-preview the value under the pointer:
+| Package              | Description                                      |
+| -------------------- | ------------------------------------------------ |
+| `packages/ropav`     | The component library                            |
+| `packages/styles`    | CSS + `tv()` variants (`@ropav/styles`)          |
+| `packages/storybook` | Storybook — the only place to see components run |
+| `packages/testing`   | Shared test harness (jsdom + Playwright browser) |
 
-```vue
-<Slider
-  v-model="currentTime"
-  :max="duration"
-  thumb="interaction"
-  :tooltip="{ anchor: 'pointer' }"
-  :format-value="formatTime"
->
-  <template #track-underlay="{ getPercent }">
-    <span
-      v-for="range in bufferedRanges"
-      :key="range.start"
-      class="buffered-range"
-      :style="{
-        left: `${getPercent(range.start)}%`,
-        width: `${getPercent(range.end) - getPercent(range.start)}%`,
-      }"
-    />
-  </template>
-  <template #tooltip-content="{ formattedValue }">
-    {{ formattedValue }}
-  </template>
-</Slider>
-```
-
-`track-underlay` and `track-overlay` are decorative layers below and above the selected range. Both
-receive the normalized slider state and a clamped `getPercent(value)` helper, so consumers can draw
-segments, markers, waveforms, or other track content without replacing slider behavior. Their
-coordinate space follows the thumb travel, so percentage positions stay aligned with the control.
-Set `:thumb="false"` to hide only the visual thumb while preserving the native input, hit area, and
-keyboard behavior. An object can combine visibility and geometry, for example
-`:thumb="{ visibility: 'interaction', size: 20 }"`.
-
-## Icons
-
-Ropav provides a compiler for
-[`unplugin-icons`](https://github.com/unplugin/unplugin-icons) that emits each
-icon as a zero-VDOM Vue Vapor component.
+## Development
 
-Install `unplugin-icons`, a matching version of `@vue/compiler-vapor`, and the
-Iconify collection you want to use:
+Requires Node.js 22+ and pnpm 10+.
 
 ```bash
-pnpm add -D unplugin-icons @vue/compiler-vapor @iconify-json/lucide
-```
-
-Pass `vaporIconCompiler` to `unplugin-icons`:
-
-```ts
-// vite.config.ts
-import vue from '@vitejs/plugin-vue';
-import { defineConfig } from 'vite';
-import Icons from 'unplugin-icons/vite';
-import { vaporIconCompiler } from 'ropav/unplugin-icons';
-
-export default defineConfig({
-  plugins: [vue({ features: { vapor: true } }), Icons({ compiler: vaporIconCompiler() })],
-});
-```
-
-Icons can then be imported on demand. Only imported icons are included in the
-application bundle.
-
-```vue
-<script setup lang="ts" vapor>
-import IconSearch from '~icons/lucide/search';
-</script>
-
-<template>
-  <IconSearch aria-hidden="true" />
-</template>
+pnpm i --hoist   # install
+pnpm dev         # Storybook on http://127.0.0.1:6006
+pnpm build       # build every package
+pnpm lint        # ESLint
+pnpm typecheck   # vue-tsc
+pnpm test        # Vitest — jsdom + browser (needs `playwright install chromium` once)
 ```
 
-## Styling contract
-
-Use typed `classNames` and `styles`, documented state attributes, and variables listed in the packaged styles manifest. DOM nesting, internal selectors and undocumented variables are private implementation details.
-
-See the [Public Styles API](./docs/public-styles-api.md) and the generated token docs shipped in `src/styles/generated/` (`tokens.md`, `showcase.html`). Consumers can declare `reset, ropav.tokens, ropav.components, app` to establish their cascade layer order.
-
-Dark mode: set `data-scheme="dark"` on `<html>` (tokens are `light-dark()` values; without the attribute the OS preference applies).
-
-For headless floating content and custom overlay markup, see the
-[public floating API](./docs/public-floating-api.md).
-
-## Development
-
-```bash
-pnpm install
-pnpm verify
-```
+## License
 
-The `verify` script runs lint, formatting, architecture contracts, type checks, unit and storybook
-tests, and the full package verification (`test:package`). Run `pnpm run storybook` to develop
-against the component stories. Contributors should follow the
-[code architecture guide](./docs/code-architecture.md) for module seams, dependency direction, and
-testing conventions; package release is documented in the [release guide](./docs/releasing.md).
+Apache License 2.0 — see [LICENSE](./LICENSE), which keeps the original copyright.

package/dist/components/accordion/accordion-body.js

@@ -0,0 +1,25 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useAccordionContext } from "./accordion.context.js";
+import { child, createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/accordion/accordion-body.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=accordion-body><div>", 1);
+var accordion_body_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "accordion-body",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots } = useAccordionContext();
+		const n2 = t0();
+		const n1 = child(n2);
+		renderEffect(() => {
+			const _slots = unref(slots);
+			setClass(n2, _slots.body());
+			setClass(n1, unref(composeSlotClassName)(_slots.bodyInner, props.class));
+		});
+		setInsertionState(n1);
+		createSlot();
+		return n2;
+	}
+});
+//#endregion
+export { accordion_body_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/accordion/accordion-body.vue.d.vue.ts

@@ -0,0 +1,21 @@
+import type { AccordionBodyProps } from "./accordion.types";
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AccordionBodyProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/accordion/accordion-heading.js

@@ -0,0 +1,20 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useAccordionContext } from "./accordion.context.js";
+import { createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/accordion/accordion-heading.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<h3 data-slot=accordion-heading>", 1);
+var accordion_heading_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "accordion-heading",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots } = useAccordionContext();
+		const n1 = t0();
+		renderEffect(() => setClass(n1, unref(composeSlotClassName)(unref(slots).heading, props.class)));
+		setInsertionState(n1);
+		createSlot();
+		return n1;
+	}
+});
+//#endregion
+export { accordion_heading_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/accordion/accordion-heading.vue.d.vue.ts

@@ -0,0 +1,21 @@
+import type { AccordionHeadingProps } from "./accordion.types";
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AccordionHeadingProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/accordion/accordion-indicator.js

@@ -0,0 +1,28 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useAccordionContext, useAccordionItemContext } from "./accordion.context.js";
+import { dataAttr } from "../../utils/assertion.js";
+import icon_chevron_down_default from "../icons/icon-chevron-down.js";
+import { createComponent, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/accordion/accordion-indicator.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<span data-slot=accordion-indicator>", 1);
+var accordion_indicator_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "accordion-indicator",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots } = useAccordionContext();
+		const { isExpanded } = useAccordionItemContext();
+		const n3 = t0();
+		renderEffect(() => {
+			setClass(n3, unref(composeSlotClassName)(unref(slots).indicator, props.class));
+			setAttr(n3, "data-expanded", unref(dataAttr)(unref(isExpanded)));
+		});
+		setInsertionState(n3);
+		createSlot("default", null, () => {
+			return createComponent(unref(icon_chevron_down_default));
+		});
+		return n3;
+	}
+});
+//#endregion
+export { accordion_indicator_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/accordion/accordion-indicator.vue.d.vue.ts

@@ -0,0 +1,21 @@
+import type { AccordionIndicatorProps } from "./accordion.types";
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AccordionIndicatorProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/accordion/accordion-item.js

@@ -0,0 +1,53 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { provideAccordionItemContext, useAccordionContext } from "./accordion.context.js";
+import { dataAttr } from "../../utils/assertion.js";
+import { useId as useId$1 } from "../../composables/use-id.js";
+import { computed, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, setProp, template, unref } from "vue";
+//#region src/components/accordion/accordion-item.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=accordion-item>", 1);
+var accordion_item_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "accordion-item",
+	props: {
+		class: {},
+		id: {},
+		isDisabled: { type: Boolean }
+	},
+	setup(__props) {
+		const props = __props;
+		const { group, hideSeparator, slots } = useAccordionContext();
+		const itemId = useId$1(() => props.id);
+		const itemKey = computed(() => itemId.value);
+		const triggerId = computed(() => `${itemId.value}-trigger`);
+		const panelId = computed(() => `${itemId.value}-panel`);
+		const isExpanded = computed(() => group.isExpanded(itemKey.value));
+		const isDisabled = computed(() => (props.isDisabled ?? false) || group.isDisabled.value);
+		const toggle = () => {
+			if (isDisabled.value) return;
+			group.toggle(itemKey.value);
+		};
+		provideAccordionItemContext({
+			isDisabled,
+			isExpanded,
+			onTriggerKeydown: group.onTriggerKeydown,
+			panelId,
+			registerTrigger: (element) => group.registerTrigger(itemKey.value, element),
+			toggle,
+			triggerId
+		});
+		const n1 = t0();
+		renderEffect(() => {
+			const _props = props;
+			const _dataAttr = unref(dataAttr);
+			setProp(n1, "id", _props.id);
+			setClass(n1, unref(composeSlotClassName)(unref(slots).item, _props.class));
+			setAttr(n1, "data-disabled", _dataAttr(isDisabled.value));
+			setAttr(n1, "data-expanded", _dataAttr(isExpanded.value));
+			setAttr(n1, "data-hide-separator", _dataAttr(unref(hideSeparator)));
+		});
+		setInsertionState(n1);
+		createSlot();
+		return n1;
+	}
+});
+//#endregion
+export { accordion_item_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/accordion/accordion-item.vue.d.vue.ts

@@ -0,0 +1,21 @@
+import type { AccordionItemProps } from "./accordion.types";
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AccordionItemProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};