@octane-xplat/ui 0.6.0 → 0.7.1

package/src/virtual-list-layout.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest'
+import {
+	createVirtualListEntries,
+	estimateVirtualListSizes,
+	virtualListRange,
+	virtualListMeasurementKey,
+	virtualListRowKey,
+	VIRTUAL_LIST_ESTIMATED_ROW_SIZE,
+	VirtualListSizeIndex,
+} from './virtual-list-layout'
+
+describe('VirtualList size index', () => {
+	it('updates variable row heights and locates exact boundaries', () => {
+		const sizes = new VirtualListSizeIndex()
+		sizes.reset([36, 48, 60, 72])
+
+		expect(sizes.prefix(3)).toBe(144)
+		expect(sizes.indexAt(0)).toBe(0)
+		expect(sizes.indexAt(36)).toBe(1)
+		expect(sizes.indexAt(144)).toBe(3)
+		expect(sizes.set(1, 80)).toBe(32)
+		expect(sizes.total).toBe(248)
+		expect(sizes.indexAt(100)).toBe(1)
+	})
+
+	it('keeps the mounted range bounded at both ends of a long list', () => {
+		const sizes = new VirtualListSizeIndex()
+		sizes.reset(Array.from({ length: 500 }, (_, index) => 36 + (index % 4) * 12))
+
+		const top = virtualListRange(sizes, 0, 240)
+		const middle = virtualListRange(sizes, sizes.prefix(200), 240)
+		const bottom = virtualListRange(sizes, sizes.total, 240)
+
+		expect(top.start).toBe(0)
+		expect(top.end).toBeLessThan(20)
+		expect(middle.start).toBeGreaterThan(190)
+		expect(middle.start).toBeLessThan(200)
+		expect(middle.end).toBeLessThan(220)
+		expect(bottom.end).toBe(500)
+		expect(bottom.start).toBeGreaterThan(480)
+		expect(top.top).toBe(0)
+		expect(bottom.bottom).toBe(0)
+	})
+
+	it('distinguishes key and item-type identities', () => {
+		expect(virtualListRowKey('1', 'card')).not.toBe(virtualListRowKey(1, 'card'))
+		expect(virtualListRowKey('1', 'card')).not.toBe(virtualListRowKey('1', 'ad'))
+	})
+
+	it('rejects duplicate item keys', () => {
+		expect(() => createVirtualListEntries(
+			[{ id: 'same' }, { id: 'same' }],
+			(item) => item.id,
+		)).toThrow('duplicate key')
+	})
+
+	it('uses a type estimate only after four rows are measured', () => {
+		const entries = createVirtualListEntries(
+			Array.from({ length: 5 }, (_, index) => ({ id: 'r' + index })),
+			(item) => item.id,
+			() => 'row',
+		)
+
+		const measurements = new Map(entries.slice(0, 3).map((entry, index) => [
+			virtualListMeasurementKey(entry.rowKey, false),
+			{ width: 100, height: 36 + index * 12 },
+		]))
+
+		expect(estimateVirtualListSizes(entries, false, 100, measurements)[3]).toBe(
+			VIRTUAL_LIST_ESTIMATED_ROW_SIZE,
+		)
+
+		const fourth = entries[3]
+		measurements.set(virtualListMeasurementKey(fourth.rowKey, false), {
+			width: 100,
+			height: 72,
+		})
+
+		expect(estimateVirtualListSizes(entries, false, 100, measurements)[4]).toBe(54)
+	})
+})

package/src/virtual-list-layout.ts

@@ -0,0 +1,246 @@
+export type VirtualListKey = string | number
+
+export interface VirtualListRange {
+	start: number
+	end: number
+	top: number
+	bottom: number
+}
+
+export interface VirtualListEntry<T> {
+	item: T
+	index: number
+	key: VirtualListKey
+	rowKey: string
+	type: VirtualListKey
+	typeKey: string
+}
+
+export interface VirtualListSizeRecord {
+	width: number
+	height: number
+}
+
+export const VIRTUAL_LIST_ESTIMATED_ROW_SIZE = 48
+export const VIRTUAL_LIST_MIN_TYPE_SAMPLES = 4
+
+export function createVirtualListEntries<T>(
+	items: readonly T[],
+	keyExtractor: (item: T, index: number) => VirtualListKey,
+	getItemType?: (item: T, index: number) => VirtualListKey,
+): VirtualListEntry<T>[] {
+	const seen = new Set<string>()
+	return items.map((item, index) => {
+		const key = keyExtractor(item, index)
+		const type = getItemType?.(item, index) ?? 'default'
+		assertKey(key, 'keyExtractor')
+		assertKey(type, 'getItemType')
+
+		const keyToken = JSON.stringify([typeof key, key])
+		if (seen.has(keyToken)) {
+			throw new Error(`VirtualList keyExtractor returned a duplicate key at index ${index}: ${String(key)}`)
+		}
+
+		seen.add(keyToken)
+
+		return {
+			item,
+			index,
+			key,
+			type,
+			typeKey: JSON.stringify([typeof type, type]),
+			rowKey: virtualListRowKey(key, type),
+		}
+	})
+}
+
+export function virtualListMeasurementKey(rowKey: string, hasSeparator: boolean) {
+	return rowKey + (hasSeparator ? ':separator' : ':last')
+}
+
+export function estimateVirtualListSizes<T>(
+	entries: readonly VirtualListEntry<T>[],
+	hasSeparator: boolean,
+	width: number,
+	measurements: ReadonlyMap<string, VirtualListSizeRecord>,
+): number[] {
+	const totals = new Map<string, { height: number; count: number }>()
+	for (const entry of entries) {
+		const cacheKey = virtualListMeasurementKey(
+			entry.rowKey,
+			hasSeparator && entry.index < entries.length - 1,
+		)
+
+		const cached = measurements.get(cacheKey)
+		if (!cached) {
+			continue
+		}
+
+		const total = totals.get(entry.typeKey) ?? { height: 0, count: 0 }
+		total.height += cached.height
+		total.count++
+		totals.set(entry.typeKey, total)
+	}
+
+	return entries.map((entry) => {
+		const cacheKey = virtualListMeasurementKey(
+			entry.rowKey,
+			hasSeparator && entry.index < entries.length - 1,
+		)
+
+		const cached = measurements.get(cacheKey)
+		if (
+			cached &&
+			width > 0 &&
+			cached.width > 0 &&
+			Math.abs(cached.width - width) < 0.5
+		) {
+			return cached.height
+		}
+
+		const total = totals.get(entry.typeKey)
+		return total && total.count >= VIRTUAL_LIST_MIN_TYPE_SAMPLES
+			? total.height / total.count
+			: VIRTUAL_LIST_ESTIMATED_ROW_SIZE
+	})
+}
+
+/** Prefix-size index for variable-height rows. Updates and offset lookups are
+ *  logarithmic, so measuring a row does not scan the whole data set. */
+export class VirtualListSizeIndex {
+	private sizes = new Float64Array(0)
+	private tree = new Float64Array(1)
+
+	get length(): number {
+		return this.sizes.length
+	}
+
+	get total(): number {
+		return this.prefix(this.length)
+	}
+
+	reset(sizes: readonly number[]): void {
+		this.sizes = Float64Array.from(sizes, normalizeSize)
+		this.tree = new Float64Array(this.sizes.length + 1)
+
+		for (let index = 1; index <= this.sizes.length; index++) {
+			this.tree[index] += this.sizes[index - 1]
+			const parent = index + (index & -index)
+			if (parent <= this.sizes.length) {
+				this.tree[parent] += this.tree[index]
+			}
+		}
+
+	}
+
+	get(index: number): number {
+		return this.sizes[index] ?? 0
+	}
+
+	set(index: number, size: number): number {
+		if (index < 0 || index >= this.sizes.length) {
+			return 0
+		}
+
+		const next = normalizeSize(size)
+		const delta = next - this.sizes[index]
+		if (delta === 0) {
+			return 0
+		}
+
+		this.sizes[index] = next
+		for (let node = index + 1; node < this.tree.length; node += node & -node) {
+			this.tree[node] += delta
+		}
+
+		return delta
+	}
+
+	/** Sum of the first `count` row heights. */
+	prefix(count: number): number {
+		let node = Math.max(0, Math.min(this.sizes.length, Math.floor(count)))
+		let sum = 0
+		while (node > 0) {
+			sum += this.tree[node]
+			node -= node & -node
+		}
+
+		return sum
+	}
+
+	/** Index of the row containing `offset`; exact row boundaries select the
+	 *  row that starts at that boundary. */
+	indexAt(offset: number): number {
+		if (this.sizes.length === 0) {
+			return 0
+		}
+
+		const target = Math.max(0, Math.min(this.total, Number.isFinite(offset) ? offset : 0))
+		let index = 0
+		let sum = 0
+		let bit = 1
+		while (bit * 2 <= this.sizes.length) {
+			bit *= 2
+		}
+
+		for (; bit > 0; bit = Math.floor(bit / 2)) {
+			const next = index + bit
+			if (next <= this.sizes.length && sum + this.tree[next] <= target) {
+				index = next
+				sum += this.tree[next]
+			}
+		}
+
+		return Math.min(index, this.sizes.length - 1)
+	}
+}
+
+export function virtualListRange(
+	sizes: VirtualListSizeIndex,
+	scrollOffset: number,
+	viewportSize: number,
+	overscanSize = viewportSize,
+): VirtualListRange {
+	if (sizes.length === 0) {
+		return { start: 0, end: 0, top: 0, bottom: 0 }
+	}
+
+	const offset = Math.max(0, Number.isFinite(scrollOffset) ? scrollOffset : 0)
+	const viewport = Math.max(0, Number.isFinite(viewportSize) ? viewportSize : 0)
+	const overscan = Math.max(0, Number.isFinite(overscanSize) ? overscanSize : 0)
+	const start = sizes.indexAt(Math.max(0, offset - overscan))
+	const end = Math.min(
+		sizes.length,
+		Math.max(start + 1, sizes.indexAt(offset + viewport + overscan) + 1),
+	)
+
+	return {
+		start,
+		end,
+		top: sizes.prefix(start),
+		bottom: Math.max(0, sizes.total - sizes.prefix(end)),
+	}
+}
+
+/** Renderer keys include the item type so changing a key's type remounts its
+ *  row instead of carrying component state into an incompatible template. */
+export function virtualListRowKey(key: VirtualListKey, type: VirtualListKey): string {
+	return JSON.stringify([typeof key, key, typeof type, type])
+}
+
+function assertKey(value: unknown, name: string): asserts value is VirtualListKey {
+	if (
+		(typeof value !== 'string' && typeof value !== 'number') ||
+		(typeof value === 'number' && !Number.isFinite(value))
+	) {
+		throw new Error(`VirtualList ${name} must return a finite number or string`)
+	}
+}
+
+function normalizeSize(size: number): number {
+	if (!Number.isFinite(size)) {
+		return 0.01
+	}
+
+	return Math.max(0.01, size)
+}

package/src/web/index.ts

@@ -0,0 +1,11 @@
+// @octane-xplat/ui/web — web-conditioned components, re-exported for
+// backwards compatibility. Hoverable and Tooltip now also ship from the
+// root barrel (`@octane-xplat/ui`): their touch-target leaves degrade to
+// passthroughs that render only the trigger/children, so shared `.tsrx`
+// can import them unconditionally. The `ui/web` subpath still resolves
+// only under the `web`/`linux` conditions.
+
+export { Hoverable } from '../Hoverable.web.tsrx'
+export { Tooltip } from '../Tooltip.web.tsrx'
+
+export type { HoverableProps, TooltipProps } from '../props'

package/src/windows.linux.ts

@@ -0,0 +1,59 @@
+// Windows — Linux webview leaf. Each openWindow() asks the host for a new
+// GTK window + WebKitWebView (its own Octane root) loading options.url
+// against the same bundle base; options.data arrives in the new root as
+// window.__xplatWindowData (document-start injection — the content resolver
+// seam, per #59). The client assigns the id so the controller is available
+// synchronously. Unbridged dev degrades to window.open.
+import type { OpenWindowOptions } from './props'
+
+export interface LinuxWindowHandle {
+	readonly id: string
+	readonly closed: Promise<void>
+	close(): void
+	setTitle(title: string): void
+}
+
+const bridge = () => (globalThis as any).__xplatBridge
+let seq = 0
+
+export function openWindow(
+	options: OpenWindowOptions & {
+		kind?: 'regular' | 'dialog'
+		title?: string
+		size?: { width: number; height: number }
+	} = {},
+): LinuxWindowHandle | Window | null {
+	if (!bridge()?.call) {
+		return window.open(options.url ?? window.location.href, '_blank')
+	}
+
+	const id = `w${++seq}`
+	let resolveClosed: () => void = () => {}
+	const closed = new Promise<void>((resolve) => {
+		resolveClosed = resolve
+	})
+	const off = bridge().on('windows', 'closed', (wid: unknown) => {
+		if (wid === id) {
+			off()
+			resolveClosed()
+		}
+	})
+
+	void bridge()
+		.call('windows', 'open', [{ ...options, id }])
+		.catch(() => {
+			off()
+			resolveClosed()
+		})
+
+	return {
+		id,
+		closed,
+		close() {
+			void bridge().call('windows', 'close', [id]).catch(() => {})
+		},
+		setTitle(title: string) {
+			void bridge().call('windows', 'setTitle', [id, title]).catch(() => {})
+		},
+	}
+}

package/src/windows.macos.ts

@@ -0,0 +1,10 @@
+import type { OpenWindowOptions } from './props'
+
+export function openWindow(options: OpenWindowOptions = {}): void {
+	const open = (globalThis as any).__xplatAppKitOpenWindow
+	if (typeof open !== 'function') {
+		console.warn('[octane-xplat] Window creation is unsupported by the current AppKit host.')
+		return
+	}
+	open(options)
+}

package/src/windows.ts

@@ -0,0 +1,7 @@
+import { Application } from '@nativescript/core'
+import type { OpenWindowOptions } from './props'
+
+/** Open another NativeScript window and pass app-owned data to its resolver. */
+export function openWindow(options: OpenWindowOptions = {}): void {
+	Application.openWindow(options)
+}

package/src/windows.web.ts

@@ -0,0 +1,6 @@
+import type { OpenWindowOptions } from './props'
+
+/** Open a browser window using the current route unless a URL is supplied. */
+export function openWindow(options: OpenWindowOptions = {}): Window | null {
+	return window.open(options.url ?? window.location.href, '_blank')
+}

package/types/generated/.tsrx-typegen-manifest.json

@@ -0,0 +1,249 @@
+{
+  "version": 1,
+  "files": [
+    "Absolute.d.ts",
+    "Absolute.web.d.ts",
+    "Accordion.d.ts",
+    "Accordion.web.d.ts",
+    "ActivityIndicator.d.ts",
+    "ActivityIndicator.web.d.ts",
+    "Alert.d.ts",
+    "Alert.web.d.ts",
+    "Avatar.d.ts",
+    "Avatar.web.d.ts",
+    "AvatarGroup.d.ts",
+    "AvatarGroup.web.d.ts",
+    "Badge.d.ts",
+    "Badge.web.d.ts",
+    "Banner.d.ts",
+    "Banner.web.d.ts",
+    "Breadcrumb.d.ts",
+    "Breadcrumb.web.d.ts",
+    "Button.d.ts",
+    "Button.web.d.ts",
+    "Card.d.ts",
+    "Card.web.d.ts",
+    "Checkbox.d.ts",
+    "Checkbox.web.d.ts",
+    "CheckboxGroup.d.ts",
+    "CheckboxGroup.web.d.ts",
+    "Chip.d.ts",
+    "Chip.web.d.ts",
+    "Collapsible.d.ts",
+    "Collapsible.web.d.ts",
+    "CommandPalette.d.ts",
+    "CommandPalette.web.d.ts",
+    "ContextMenu.d.ts",
+    "ContextMenu.web.d.ts",
+    "Drawer.d.ts",
+    "Drawer.web.d.ts",
+    "DropdownMenu.d.ts",
+    "DropdownMenu.web.d.ts",
+    "Empty.d.ts",
+    "Empty.web.d.ts",
+    "FieldGroup.d.ts",
+    "FieldGroup.web.d.ts",
+    "FormField.d.ts",
+    "FormField.web.d.ts",
+    "Grid.d.ts",
+    "Grid.web.d.ts",
+    "Heading.d.ts",
+    "Heading.web.d.ts",
+    "Hoverable.d.ts",
+    "Hoverable.web.d.ts",
+    "Icon.d.ts",
+    "Icon.web.d.ts",
+    "Image.d.ts",
+    "Image.web.d.ts",
+    "InputNumber.d.ts",
+    "InputNumber.web.d.ts",
+    "InputRating.d.ts",
+    "InputRating.web.d.ts",
+    "InputTags.d.ts",
+    "InputTags.web.d.ts",
+    "Kbd.d.ts",
+    "Kbd.web.d.ts",
+    "KeyboardAvoiding.mobile.d.ts",
+    "Link.d.ts",
+    "Link.web.d.ts",
+    "ListItem.d.ts",
+    "ListItem.web.d.ts",
+    "Meter.d.ts",
+    "Meter.web.d.ts",
+    "NavLink.d.ts",
+    "NavLink.web.d.ts",
+    "NavigationMenu.d.ts",
+    "NavigationMenu.web.d.ts",
+    "Overlay.d.ts",
+    "Overlay.web.d.ts",
+    "Pagination.d.ts",
+    "Pagination.web.d.ts",
+    "PinInput.d.ts",
+    "PinInput.web.d.ts",
+    "Popover.d.ts",
+    "Popover.web.d.ts",
+    "Pressable.d.ts",
+    "Pressable.web.d.ts",
+    "ProgressGroup.d.ts",
+    "ProgressGroup.web.d.ts",
+    "RadioGroup.d.ts",
+    "RadioGroup.web.d.ts",
+    "RichText.d.ts",
+    "RichText.web.d.ts",
+    "RouteHost.mobile.d.ts",
+    "Row.d.ts",
+    "Row.web.d.ts",
+    "SafeArea.d.ts",
+    "SafeArea.web.d.ts",
+    "Screen.d.ts",
+    "Screen.web.d.ts",
+    "ScrollBox.d.ts",
+    "ScrollBox.web.d.ts",
+    "ScrollView.d.ts",
+    "ScrollView.web.d.ts",
+    "SearchInput.d.ts",
+    "SearchInput.web.d.ts",
+    "SegmentedControl.d.ts",
+    "SegmentedControl.web.d.ts",
+    "Select.d.ts",
+    "Select.web.d.ts",
+    "Separator.d.ts",
+    "Separator.web.d.ts",
+    "Sheet.d.ts",
+    "Sheet.web.d.ts",
+    "Skeleton.d.ts",
+    "Skeleton.web.d.ts",
+    "Slider.d.ts",
+    "Slider.web.d.ts",
+    "Spacer.d.ts",
+    "Spacer.web.d.ts",
+    "Stack.d.ts",
+    "Stack.web.d.ts",
+    "Stepper.d.ts",
+    "Stepper.web.d.ts",
+    "Switch.d.ts",
+    "Switch.web.d.ts",
+    "Table.d.ts",
+    "Table.web.d.ts",
+    "Tabs.d.ts",
+    "Tabs.web.d.ts",
+    "Text.d.ts",
+    "Text.web.d.ts",
+    "TextArea.d.ts",
+    "TextArea.web.d.ts",
+    "TextInput.d.ts",
+    "TextInput.web.d.ts",
+    "Timeline.d.ts",
+    "Timeline.web.d.ts",
+    "Tooltip.d.ts",
+    "Tooltip.web.d.ts",
+    "Tree.d.ts",
+    "Tree.web.d.ts",
+    "User.d.ts",
+    "User.web.d.ts",
+    "View.d.ts",
+    "View.web.d.ts",
+    "VirtualList.d.ts",
+    "VirtualList.web.d.ts",
+    "WebView.d.ts",
+    "WebView.web.d.ts",
+    "aliases.d.ts",
+    "aliases.web.d.ts",
+    "android/BottomNavigationView.android.d.ts",
+    "android/CircularProgressIndicator.android.d.ts",
+    "android/DrawerLayout.android.d.ts",
+    "android/MaterialDialog.android.d.ts",
+    "android/MaterialSwitch.android.d.ts",
+    "android/RecyclerView.android.d.ts",
+    "android/SeekBar.android.d.ts",
+    "android/icon.android.d.ts",
+    "android/index.d.ts",
+    "android/openModal.android.d.ts",
+    "anim.d.ts",
+    "anim.web.d.ts",
+    "apply-native-modifiers.native.d.ts",
+    "child-array.d.ts",
+    "cx.d.ts",
+    "escape-props.d.ts",
+    "icons.d.ts",
+    "index.d.ts",
+    "index.linux.d.ts",
+    "index.mobile.d.ts",
+    "index.shared.d.ts",
+    "index.web.d.ts",
+    "ios/LiquidGlass.ios.d.ts",
+    "ios/LiquidGlassContainer.ios.d.ts",
+    "ios/SideDrawer.ios.d.ts",
+    "ios/UIActivityIndicatorView.ios.d.ts",
+    "ios/UIModal.ios.d.ts",
+    "ios/UISlider.ios.d.ts",
+    "ios/UISwitch.ios.d.ts",
+    "ios/UITabBar.ios.d.ts",
+    "ios/UITableView.ios.d.ts",
+    "ios/icon.ios.d.ts",
+    "ios/index.d.ts",
+    "ios/openModal.ios.d.ts",
+    "keyboard-inset.mobile.d.ts",
+    "layout-child.d.ts",
+    "layout-child.web.d.ts",
+    "meter-math.d.ts",
+    "modal-presenter.mobile.d.ts",
+    "modifier-factories.d.ts",
+    "native/index.d.ts",
+    "pan.d.ts",
+    "pan.web.d.ts",
+    "platform.d.ts",
+    "platform.web.d.ts",
+    "platformProps.d.ts",
+    "platformProps.web.d.ts",
+    "popover-position.d.ts",
+    "props.d.ts",
+    "refresh-metrics.d.ts",
+    "refresh.d.ts",
+    "refresh.web.d.ts",
+    "root-layout.mobile.d.ts",
+    "route-host.mobile.d.ts",
+    "route-table.d.ts",
+    "route.d.ts",
+    "route.web.d.ts",
+    "safeAreaInsets.d.ts",
+    "safeAreaInsets.web.d.ts",
+    "sheet-detents.d.ts",
+    "sheet-detents.web.d.ts",
+    "sheet-service.d.ts",
+    "sheet-service.web.d.ts",
+    "sheet-snap.d.ts",
+    "stacks.d.ts",
+    "stacks.web.d.ts",
+    "store.d.ts",
+    "styled.d.ts",
+    "styled.web.d.ts",
+    "svg.mobile.d.ts",
+    "tap-to-blur.mobile.d.ts",
+    "text-write.d.ts",
+    "theme/colorScheme.d.ts",
+    "theme/colorScheme.linux.d.ts",
+    "theme/colorScheme.web.d.ts",
+    "theme/status-bar-scheme.mobile.d.ts",
+    "theme/theme-scheme.d.ts",
+    "toast-anchor.d.ts",
+    "toast-anchor.web.d.ts",
+    "transform.web.d.ts",
+    "translate.d.ts",
+    "translate.web.d.ts",
+    "use-back.d.ts",
+    "use-back.web.d.ts",
+    "use-store.d.ts",
+    "use-store.web.d.ts",
+    "useMeasure.d.ts",
+    "useMeasure.web.d.ts",
+    "vendor/ui-svg/index.common.d.ts",
+    "vendor/ui-svg/index.d.ts",
+    "vendor/ui-svg/index.ios.d.ts",
+    "virtual-list-layout.d.ts",
+    "web/index.d.ts",
+    "windows.d.ts",
+    "windows.linux.d.ts",
+    "windows.web.d.ts"
+  ]
+}

package/types/generated/Absolute.d.ts

@@ -0,0 +1,3 @@
+/**  @jsxImportSource @nativescript-community/octane */
+import type { AbsoluteProps } from './props.js';
+export declare function Absolute(props: AbsoluteProps): unknown;

package/types/generated/Absolute.web.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource octane */
+import type { AbsoluteProps } from './props.js';
+export declare function Absolute(props: AbsoluteProps): import("octane/jsx-runtime").JSX.Element;

package/types/generated/Accordion.d.ts

@@ -0,0 +1,5 @@
+import type { AccordionProps } from "./props.js";
+/**  Self-drawn accordion — a list of Collapsibles sharing one open-state.
+ *  Controlled via `open` (key, or keys with `multiple`), uncontrolled via
+ *  `defaultOpen`. */
+export declare function Accordion(props: AccordionProps): unknown;

package/types/generated/Accordion.web.d.ts

@@ -0,0 +1,5 @@
+import type { AccordionProps } from "./props.js";
+/**  Self-drawn accordion — a list of Collapsibles sharing one open-state.
+ *  Controlled via `open` (key, or keys with `multiple`), uncontrolled via
+ *  `defaultOpen`. */
+export declare function Accordion(props: AccordionProps): import("octane/jsx-runtime").JSX.Element;