@brickkit/cli 0.10.0 → 0.11.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dashboard-dist/CollapsiblePanel-BX79_W-b.js +2 -0
- package/dashboard-dist/CompositeRoot-xzybXjnx.js +1 -0
- package/dashboard-dist/PopoverPopup-CvlmC7EL.js +1 -0
- package/dashboard-dist/{api-reference-r893F8zi.js → api-reference-BcAYVYwJ.js} +8 -8
- package/dashboard-dist/app.css +1 -1
- package/dashboard-dist/app.js +13 -13
- package/dashboard-dist/core-BGO9JZ1r.js +1 -0
- package/dashboard-dist/docs-DHikPD2v.js +4 -0
- package/dashboard-dist/kit.js +1 -0
- package/dashboard-dist/popover-DG498XHH.js +1 -0
- package/dashboard-dist/react-dom-client.js +3 -0
- package/dashboard-dist/react-dom.js +3 -0
- package/dashboard-dist/react-jsx-runtime.js +1 -1
- package/dashboard-dist/react.js +3 -3
- package/dashboard-dist/theme.css +123 -0
- package/dist/bin.d.ts.map +1 -1
- package/dist/bin.js +440 -44
- package/dist/bin.js.map +1 -1
- package/dist/client-contract-file2.js +1 -1
- package/dist/client-contract2.js +12 -6
- package/dist/client-contract2.js.map +1 -1
- package/dist/config.js +252 -0
- package/dist/config.js.map +1 -0
- package/dist/dashboard-extension.d.ts +27 -0
- package/dist/dashboard-extension.d.ts.map +1 -0
- package/dist/dashboard.d.ts +3127 -0
- package/dist/dev-telemetry-store.js +1407 -952
- package/dist/dev-telemetry-store.js.map +1 -1
- package/dist/dev-worker.js +2 -2
- package/dist/index.d.ts +95 -6
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +4 -4
- package/dist/lint/eslint.d.ts +2 -0
- package/dist/lint/eslint.js +1 -0
- package/dist/lint/oxlint.d.ts +19 -0
- package/dist/lint/oxlint.d.ts.map +1 -0
- package/dist/lint/oxlint.js +19 -0
- package/dist/lint/oxlint.js.map +1 -0
- package/dist/plugin.d.ts +76 -0
- package/dist/plugin.d.ts.map +1 -0
- package/dist/plugin.js +66 -0
- package/dist/plugin.js.map +1 -0
- package/dist/presets.js +1070 -0
- package/dist/presets.js.map +1 -0
- package/dist/runner.js +112 -26
- package/dist/runner.js.map +1 -1
- package/dist/vite.d.ts +6 -3
- package/dist/vite.d.ts.map +1 -1
- package/dist/vite.js +9 -3
- package/dist/vite.js.map +1 -1
- package/dist/workflows2.js +1 -1
- package/inspector-dist/client/assets/app-CvoGgWcV.css +1 -0
- package/inspector-dist/client/assets/{manifest-4baa7c6f.js → manifest-139c9319.js} +1 -1
- package/inspector-dist/client/assets/root-BMHd_XHz.css +1 -0
- package/inspector-dist/server/assets/{app-C-ZVJtic.js → app-DUP5RybL.js} +11 -11
- package/inspector-dist/server/assets/{highlighted-body-B3W2YXNL-C8sq8F_D.js → highlighted-body-B3W2YXNL-D2g4hL2-.js} +1 -1
- package/inspector-dist/server/assets/{index-CYlmUaKx.js → index-D71yP6AL.js} +2 -2
- package/inspector-dist/server/assets/{index-CWJr34WJ.js → index-wGSWRns3.js} +1 -1
- package/inspector-dist/server/assets/{mermaid-3ZIDBTTL-Dv5rjfMN.js → mermaid-3ZIDBTTL-DsvuKoEV.js} +1 -1
- package/inspector-dist/server/assets/{token-DnLp3wBO.js → token-ClUZZwXl.js} +1 -1
- package/inspector-dist/server/assets/{token-util-Bpfp-B0w.js → token-util-DSxMZ6nI.js} +1 -1
- package/inspector-dist/server/assets/{wrapper-D5LIcZ_u.js → wrapper-B3vstpCO.js} +2 -2
- package/inspector-dist/server/assets/{zstd-browser-decoder-BM8GpVB8.js → zstd-browser-decoder-Dn82m2BU.js} +1 -1
- package/inspector-dist/server/index.js +1 -1
- package/package.json +30 -6
- package/dashboard-dist/CollapsiblePanel-a54TwMKb.js +0 -2
- package/dashboard-dist/PopoverPopup-BLzjTqsi.js +0 -1
- package/dashboard-dist/core-BWAwhSFf.js +0 -1
- package/dashboard-dist/docs-CkMy3Y5i.js +0 -4
- package/dashboard-dist/preload-helper-CjQDFR0M.js +0 -1
- package/dist/build.js +0 -119
- package/dist/build.js.map +0 -1
- package/inspector-dist/client/assets/app-CY7CQBRo.css +0 -1
- package/inspector-dist/client/assets/root-CfCr265_.css +0 -1
- /package/inspector-dist/client/assets/{root-Bmn5n3jF.js → root-cbi6iYwg.js} +0 -0
|
@@ -0,0 +1,3127 @@
|
|
|
1
|
+
import * as React$1 from "react";
|
|
2
|
+
import { ComponentProps, ComponentType, ReactNode } from "react";
|
|
3
|
+
import { Attributes } from "@opentelemetry/api";
|
|
4
|
+
import { ArchitectureSchema } from "@brickkit/core";
|
|
5
|
+
import { BrickClient, BrickClientOptions } from "@brickkit/core/client";
|
|
6
|
+
import { VariantProps } from "class-variance-authority";
|
|
7
|
+
//#region src/dev-telemetry.d.ts
|
|
8
|
+
interface SpanEventRecord {
|
|
9
|
+
name: string;
|
|
10
|
+
timeMs: number;
|
|
11
|
+
attributes: Attributes;
|
|
12
|
+
}
|
|
13
|
+
//#endregion
|
|
14
|
+
//#region src/dev-telemetry-store.d.ts
|
|
15
|
+
type SpanOutcome = "running" | "ok" | "error" | "interrupted";
|
|
16
|
+
interface TraceSpan {
|
|
17
|
+
spanId: string;
|
|
18
|
+
parentSpanId?: string;
|
|
19
|
+
name: string;
|
|
20
|
+
startMs: number;
|
|
21
|
+
endMs?: number;
|
|
22
|
+
status: SpanOutcome;
|
|
23
|
+
statusMessage?: string;
|
|
24
|
+
attributes: Attributes;
|
|
25
|
+
events: SpanEventRecord[];
|
|
26
|
+
}
|
|
27
|
+
interface TraceSummary {
|
|
28
|
+
traceId: string;
|
|
29
|
+
name: string;
|
|
30
|
+
method?: string;
|
|
31
|
+
route?: string;
|
|
32
|
+
/** The request's actual path, which differs from a wildcard route template. */
|
|
33
|
+
path?: string;
|
|
34
|
+
httpStatus?: number;
|
|
35
|
+
generation: number;
|
|
36
|
+
startMs: number;
|
|
37
|
+
endMs?: number;
|
|
38
|
+
durationMs?: number;
|
|
39
|
+
status: SpanOutcome;
|
|
40
|
+
truncated: boolean;
|
|
41
|
+
/** The service and action that handled the request, when it ran one. */
|
|
42
|
+
service?: string;
|
|
43
|
+
action?: string;
|
|
44
|
+
/** Why it failed, when it did. */
|
|
45
|
+
message?: string;
|
|
46
|
+
/** The request used a v0.10 path that `brick({ legacyRoutes: true })` still serves. */
|
|
47
|
+
legacyRoute?: boolean;
|
|
48
|
+
spans: TraceSpan[];
|
|
49
|
+
}
|
|
50
|
+
//#endregion
|
|
51
|
+
//#region dashboard/state.d.ts
|
|
52
|
+
type View = "requests" | "logs" | "overview" | "apis" | "docs" | "workflows" | "errors" | "reloads" |
|
|
53
|
+
/** An extension's page, at `#/x/<id>/…`, so it never clashes with a built-in one. */
|
|
54
|
+
"x";
|
|
55
|
+
interface Route {
|
|
56
|
+
view: View;
|
|
57
|
+
traceId?: string;
|
|
58
|
+
/** Segments after the view, for views with pages of their own (APIs, Docs). For `x`, after the page's id. */
|
|
59
|
+
path: string[];
|
|
60
|
+
/** The `#heading` after a docs page's path. */
|
|
61
|
+
anchor?: string;
|
|
62
|
+
/** The extension page's id, for `x`. */
|
|
63
|
+
page?: string;
|
|
64
|
+
}
|
|
65
|
+
//#endregion
|
|
66
|
+
//#region dashboard/extension-registry.d.ts
|
|
67
|
+
/** What every slot, page and drawer tab receives. */
|
|
68
|
+
interface SlotContext {
|
|
69
|
+
/** Where the dashboard is: `#/x/queues/42` is `{ view: "x", page: "queues", path: ["42"] }`. */
|
|
70
|
+
route: Route;
|
|
71
|
+
/** The theme in effect, after following the system setting. */
|
|
72
|
+
theme: "light" | "dark";
|
|
73
|
+
/** The read-only dashboard of `brick start`, not `brick dev`. */
|
|
74
|
+
production: boolean;
|
|
75
|
+
/** The request open in the Requests view, when one is. */
|
|
76
|
+
selectedRequestId?: string;
|
|
77
|
+
}
|
|
78
|
+
interface SidebarSlotContext extends SlotContext {
|
|
79
|
+
/** Whether the sidebar shows labels, or only its icon rail. */
|
|
80
|
+
expanded: boolean;
|
|
81
|
+
}
|
|
82
|
+
interface DrawerTabContext extends SlotContext {
|
|
83
|
+
/** The request the drawer shows; undefined while its spans load. */
|
|
84
|
+
request: TraceSummary | undefined;
|
|
85
|
+
}
|
|
86
|
+
/** A tab of the request drawer, beside its own Details. */
|
|
87
|
+
interface DrawerTab {
|
|
88
|
+
id: string;
|
|
89
|
+
label: string;
|
|
90
|
+
component: ComponentType<DrawerTabContext>;
|
|
91
|
+
}
|
|
92
|
+
/** The fixed places an extension can fill. */
|
|
93
|
+
interface DashboardSlots {
|
|
94
|
+
"topbar.start"?: ComponentType<SlotContext>;
|
|
95
|
+
"topbar.end"?: ComponentType<SlotContext>;
|
|
96
|
+
"sidebar.header"?: ComponentType<SidebarSlotContext>;
|
|
97
|
+
"sidebar.footer"?: ComponentType<SidebarSlotContext>;
|
|
98
|
+
"overview.top"?: ComponentType<SlotContext>;
|
|
99
|
+
"request.drawer.tabs"?: DrawerTab[];
|
|
100
|
+
}
|
|
101
|
+
type SlotName = keyof DashboardSlots;
|
|
102
|
+
interface PageProps extends SlotContext {
|
|
103
|
+
/** The address after the page's own: `#/x/queues/a/b` gives `["a", "b"]`. */
|
|
104
|
+
path: string[];
|
|
105
|
+
}
|
|
106
|
+
/** Where a page or link sits in the sidebar. */
|
|
107
|
+
interface Placement {
|
|
108
|
+
/** After this page: a built-in one (`"overview"`) or another extension page's id. */
|
|
109
|
+
after?: string;
|
|
110
|
+
/** Under this heading, below the built-in pages. `after` wins when both are set. */
|
|
111
|
+
section?: string;
|
|
112
|
+
/** Show it in the production dashboard of `brick start` too. */
|
|
113
|
+
production?: boolean;
|
|
114
|
+
}
|
|
115
|
+
interface PageBase extends Placement {
|
|
116
|
+
/** Its address is `#/x/<id>`: letters, digits and dashes. */
|
|
117
|
+
id: string;
|
|
118
|
+
label: string;
|
|
119
|
+
icon?: ReactNode;
|
|
120
|
+
}
|
|
121
|
+
type ExtensionPage = (PageBase & {
|
|
122
|
+
component: ComponentType<PageProps>;
|
|
123
|
+
url?: undefined;
|
|
124
|
+
}) |
|
|
125
|
+
/** A page shown in a frame. It cannot fill slots or follow the theme. */
|
|
126
|
+
(PageBase & {
|
|
127
|
+
url: string;
|
|
128
|
+
component?: undefined;
|
|
129
|
+
});
|
|
130
|
+
/** A sidebar link. One to another site opens in a new tab. */
|
|
131
|
+
interface SidebarLink extends Placement {
|
|
132
|
+
label: string;
|
|
133
|
+
icon?: ReactNode;
|
|
134
|
+
href: string;
|
|
135
|
+
}
|
|
136
|
+
interface DashboardExtension {
|
|
137
|
+
/** Wraps the whole dashboard: providers, analytics, feature flags. */
|
|
138
|
+
root?: ComponentType<{
|
|
139
|
+
children: ReactNode;
|
|
140
|
+
}>;
|
|
141
|
+
slots?: DashboardSlots;
|
|
142
|
+
pages?: ExtensionPage[];
|
|
143
|
+
sidebar?: SidebarLink[];
|
|
144
|
+
}
|
|
145
|
+
/** Declare the dashboard extension; the module's default export. */
|
|
146
|
+
export declare function defineDashboard<T extends DashboardExtension>(extension: T): T;
|
|
147
|
+
//#endregion
|
|
148
|
+
//#region dashboard/extension.d.ts
|
|
149
|
+
/** The requests the dashboard holds live, newest first. */
|
|
150
|
+
export declare function useRequests(): TraceSummary[];
|
|
151
|
+
/** The app's services, actions and routes as last started; null before it starts. */
|
|
152
|
+
export declare function useArchitecture(): ArchitectureSchema | null;
|
|
153
|
+
/**
|
|
154
|
+
* Call the app through the dashboard's `/app` proxy, from the dashboard's own
|
|
155
|
+
* origin. `path` is the app's: `appFetch("/api/admin/queues")`.
|
|
156
|
+
*/
|
|
157
|
+
export declare function appFetch(path: string, init?: RequestInit): Promise<Response>;
|
|
158
|
+
interface AppFetchResult<T> {
|
|
159
|
+
data: T | undefined;
|
|
160
|
+
error: Error | undefined;
|
|
161
|
+
loading: boolean;
|
|
162
|
+
/** Fetch again. */
|
|
163
|
+
refetch: () => void;
|
|
164
|
+
}
|
|
165
|
+
/**
|
|
166
|
+
* The app's typed client, calling it through the dashboard's `/app` proxy:
|
|
167
|
+
* `createAppClient<AppContract>({ contract })`, with both from the contract
|
|
168
|
+
* `brick dev` generates. CRUD and other plugin routes need the `contract`
|
|
169
|
+
* value. Headers, the prefix and timeouts are as for `createBrickClient`.
|
|
170
|
+
*/
|
|
171
|
+
export declare function createAppClient<TApp extends Record<string, any>>(options?: Omit<BrickClientOptions, "baseUrl"> & {
|
|
172
|
+
contract?: TApp;
|
|
173
|
+
}): BrickClient<TApp>;
|
|
174
|
+
/**
|
|
175
|
+
* Run `query` when the component mounts and whenever `deps` change, as
|
|
176
|
+
* `useEffect` would: `useAppQuery((signal) => api.orders.order.list({}, { signal }), [])`.
|
|
177
|
+
* A `null` query waits. The signal aborts when deps change or on unmount.
|
|
178
|
+
*/
|
|
179
|
+
export declare function useAppQuery<T>(query: ((signal: AbortSignal) => Promise<T>) | null, deps: readonly unknown[]): AppFetchResult<T>;
|
|
180
|
+
/**
|
|
181
|
+
* Read `path` from the app (JSON, or text for anything else) when the
|
|
182
|
+
* component mounts and whenever `path` changes. A `null` path waits.
|
|
183
|
+
*/
|
|
184
|
+
export declare function useAppFetch<T = unknown>(path: string | null, init?: RequestInit): AppFetchResult<T>;
|
|
185
|
+
//#endregion
|
|
186
|
+
//#region dashboard/components/panel.d.ts
|
|
187
|
+
/**
|
|
188
|
+
* Efferd's card: a square, 1px-bordered surface with a plus mark on each
|
|
189
|
+
* corner, built on the shadcn Card with its radius and ring removed. A `title`
|
|
190
|
+
* is a heading row across the top.
|
|
191
|
+
*/
|
|
192
|
+
export declare function Panel({ className, children, title, ...props }: Omit<ComponentProps<"div">, "title"> & {
|
|
193
|
+
title?: ReactNode;
|
|
194
|
+
}): import("react").JSX.Element;
|
|
195
|
+
//#endregion
|
|
196
|
+
//#region dashboard/components/metric.d.ts
|
|
197
|
+
/** Miniature stacked-block bar chart, with the newest column emphasized. */
|
|
198
|
+
export declare function SparkBars({ values }: {
|
|
199
|
+
values: number[];
|
|
200
|
+
}): import("react").JSX.Element;
|
|
201
|
+
export declare function Metric({ icon, label, value, note, spark }: {
|
|
202
|
+
icon?: ReactNode;
|
|
203
|
+
label: string;
|
|
204
|
+
value: ReactNode;
|
|
205
|
+
/** A line under the value. */
|
|
206
|
+
note?: string;
|
|
207
|
+
/** Recent values for the miniature chart; omit for none. */
|
|
208
|
+
spark?: number[];
|
|
209
|
+
}): import("react").JSX.Element;
|
|
210
|
+
//#endregion
|
|
211
|
+
//#region dashboard/components/page-header.d.ts
|
|
212
|
+
export declare function PageHeader({ title, description, actions }: {
|
|
213
|
+
title: string;
|
|
214
|
+
description?: string;
|
|
215
|
+
actions?: ReactNode;
|
|
216
|
+
}): import("react").JSX.Element;
|
|
217
|
+
export declare function Empty({ title, hint }: {
|
|
218
|
+
title: string;
|
|
219
|
+
hint?: string;
|
|
220
|
+
}): import("react").JSX.Element;
|
|
221
|
+
//#endregion
|
|
222
|
+
//#region ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/clsx.d.mts
|
|
223
|
+
type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
|
|
224
|
+
type ClassDictionary = Record<string, any>;
|
|
225
|
+
type ClassArray = ClassValue[];
|
|
226
|
+
//#endregion
|
|
227
|
+
//#region dashboard/lib/utils.d.ts
|
|
228
|
+
export declare function cn(...inputs: ClassValue[]): string;
|
|
229
|
+
//#endregion
|
|
230
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/internals/reason-parts.d.mts
|
|
231
|
+
declare const none: 'none';
|
|
232
|
+
declare const triggerPress: 'trigger-press';
|
|
233
|
+
declare const triggerHover: 'trigger-hover';
|
|
234
|
+
declare const triggerFocus: 'trigger-focus';
|
|
235
|
+
declare const outsidePress: 'outside-press';
|
|
236
|
+
declare const itemPress: 'item-press';
|
|
237
|
+
declare const closePress: 'close-press';
|
|
238
|
+
declare const linkPress: 'link-press';
|
|
239
|
+
declare const clearPress: 'clear-press';
|
|
240
|
+
declare const chipRemovePress: 'chip-remove-press';
|
|
241
|
+
declare const trackPress: 'track-press';
|
|
242
|
+
declare const incrementPress: 'increment-press';
|
|
243
|
+
declare const decrementPress: 'decrement-press';
|
|
244
|
+
declare const inputChange: 'input-change';
|
|
245
|
+
declare const inputClear: 'input-clear';
|
|
246
|
+
declare const inputBlur: 'input-blur';
|
|
247
|
+
declare const inputPaste: 'input-paste';
|
|
248
|
+
declare const inputPress: 'input-press';
|
|
249
|
+
declare const focusOut: 'focus-out';
|
|
250
|
+
declare const escapeKey: 'escape-key';
|
|
251
|
+
declare const closeWatcher: 'close-watcher';
|
|
252
|
+
declare const listNavigation: 'list-navigation';
|
|
253
|
+
declare const keyboard: 'keyboard';
|
|
254
|
+
declare const pointer: 'pointer';
|
|
255
|
+
declare const drag: 'drag';
|
|
256
|
+
declare const wheel: 'wheel';
|
|
257
|
+
declare const scrub: 'scrub';
|
|
258
|
+
declare const cancelOpen: 'cancel-open';
|
|
259
|
+
declare const siblingOpen: 'sibling-open';
|
|
260
|
+
declare const disabled: 'disabled';
|
|
261
|
+
declare const missing: 'missing';
|
|
262
|
+
declare const initial: 'initial';
|
|
263
|
+
declare const imperativeAction: 'imperative-action';
|
|
264
|
+
declare const swipe: 'swipe';
|
|
265
|
+
declare const windowResize: 'window-resize';
|
|
266
|
+
//#endregion
|
|
267
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/internals/createBaseUIEventDetails.d.mts
|
|
268
|
+
interface ReasonToEventMap {
|
|
269
|
+
[none]: Event;
|
|
270
|
+
[triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
|
|
271
|
+
[triggerHover]: MouseEvent;
|
|
272
|
+
[triggerFocus]: FocusEvent;
|
|
273
|
+
[outsidePress]: MouseEvent | PointerEvent | TouchEvent;
|
|
274
|
+
[itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
|
|
275
|
+
[closePress]: MouseEvent | KeyboardEvent | PointerEvent;
|
|
276
|
+
[linkPress]: MouseEvent | PointerEvent;
|
|
277
|
+
[clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
|
|
278
|
+
[chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
|
|
279
|
+
[trackPress]: PointerEvent | MouseEvent | TouchEvent;
|
|
280
|
+
[incrementPress]: PointerEvent | MouseEvent | TouchEvent;
|
|
281
|
+
[decrementPress]: PointerEvent | MouseEvent | TouchEvent;
|
|
282
|
+
[inputChange]: InputEvent | Event;
|
|
283
|
+
[inputClear]: InputEvent | FocusEvent | Event;
|
|
284
|
+
[inputBlur]: FocusEvent;
|
|
285
|
+
[inputPaste]: ClipboardEvent;
|
|
286
|
+
[inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
|
|
287
|
+
[focusOut]: FocusEvent | KeyboardEvent;
|
|
288
|
+
[escapeKey]: KeyboardEvent;
|
|
289
|
+
[closeWatcher]: Event;
|
|
290
|
+
[listNavigation]: KeyboardEvent;
|
|
291
|
+
[keyboard]: KeyboardEvent;
|
|
292
|
+
[pointer]: PointerEvent;
|
|
293
|
+
[drag]: PointerEvent | TouchEvent;
|
|
294
|
+
[swipe]: PointerEvent | TouchEvent;
|
|
295
|
+
[wheel]: WheelEvent;
|
|
296
|
+
[scrub]: PointerEvent;
|
|
297
|
+
[cancelOpen]: MouseEvent;
|
|
298
|
+
[siblingOpen]: Event;
|
|
299
|
+
[disabled]: Event;
|
|
300
|
+
[missing]: Event;
|
|
301
|
+
[initial]: Event;
|
|
302
|
+
[imperativeAction]: Event;
|
|
303
|
+
[windowResize]: UIEvent;
|
|
304
|
+
}
|
|
305
|
+
/**
|
|
306
|
+
* Maps a change `reason` string to the corresponding native event type.
|
|
307
|
+
*/
|
|
308
|
+
type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
|
|
309
|
+
type BaseUIChangeEventDetail<Reason extends string, CustomProperties extends object> = {
|
|
310
|
+
/**
|
|
311
|
+
* The reason for the event.
|
|
312
|
+
*/
|
|
313
|
+
reason: Reason;
|
|
314
|
+
/**
|
|
315
|
+
* The native event associated with the custom event.
|
|
316
|
+
*/
|
|
317
|
+
event: ReasonToEvent<Reason>;
|
|
318
|
+
/**
|
|
319
|
+
* Cancels Base UI from handling the event.
|
|
320
|
+
*/
|
|
321
|
+
cancel: () => void;
|
|
322
|
+
/**
|
|
323
|
+
* Allows the event to propagate in cases where Base UI will stop the propagation.
|
|
324
|
+
*/
|
|
325
|
+
allowPropagation: () => void;
|
|
326
|
+
/**
|
|
327
|
+
* Indicates whether the event has been canceled.
|
|
328
|
+
*/
|
|
329
|
+
isCanceled: boolean;
|
|
330
|
+
/**
|
|
331
|
+
* Indicates whether the event is allowed to propagate.
|
|
332
|
+
*/
|
|
333
|
+
isPropagationAllowed: boolean;
|
|
334
|
+
/**
|
|
335
|
+
* The element that triggered the event, if applicable.
|
|
336
|
+
*/
|
|
337
|
+
trigger: Element | undefined;
|
|
338
|
+
} & CustomProperties;
|
|
339
|
+
/**
|
|
340
|
+
* Details of custom change events emitted by Base UI components.
|
|
341
|
+
*/
|
|
342
|
+
type BaseUIChangeEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIChangeEventDetail<Reason, CustomProperties> & {} : never;
|
|
343
|
+
//#endregion
|
|
344
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/types/index.d.mts
|
|
345
|
+
type HTMLProps<T = any> = React$1.HTMLAttributes<T> & {
|
|
346
|
+
ref?: React$1.Ref<T> | undefined;
|
|
347
|
+
};
|
|
348
|
+
/**
|
|
349
|
+
* Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
|
|
350
|
+
*
|
|
351
|
+
* @template Props Props to be spread on the rendered element.
|
|
352
|
+
* @template State Component's internal state.
|
|
353
|
+
*/
|
|
354
|
+
type ComponentRenderFn<Props, State> = (props: Props, state: State) => React$1.ReactElement<unknown>;
|
|
355
|
+
type BaseUIEvent<E extends React$1.SyntheticEvent<Element, Event>> = E & {
|
|
356
|
+
preventBaseUIHandler: () => void;
|
|
357
|
+
readonly baseUIHandlerPrevented?: boolean | undefined;
|
|
358
|
+
};
|
|
359
|
+
//#endregion
|
|
360
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/internals/types.d.mts
|
|
361
|
+
type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React$1.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
|
|
362
|
+
/**
|
|
363
|
+
* Adds a `preventBaseUIHandler` method to all event handlers.
|
|
364
|
+
*/
|
|
365
|
+
type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]>; };
|
|
366
|
+
/**
|
|
367
|
+
* Props shared by all Base UI components.
|
|
368
|
+
* Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
|
|
369
|
+
*/
|
|
370
|
+
type BaseUIComponentProps<ElementType extends React$1.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React$1.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
|
|
371
|
+
/**
|
|
372
|
+
* CSS class applied to the element, or a function that
|
|
373
|
+
* returns a class based on the component's state.
|
|
374
|
+
*/
|
|
375
|
+
className?: string | ((state: State) => string | undefined) | undefined;
|
|
376
|
+
/**
|
|
377
|
+
* Allows you to replace the component's HTML element
|
|
378
|
+
* with a different tag, or compose it with another component.
|
|
379
|
+
*
|
|
380
|
+
* Accepts a `ReactElement` or a function that returns the element to render.
|
|
381
|
+
*/
|
|
382
|
+
render?: React$1.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
|
|
383
|
+
/**
|
|
384
|
+
* Style applied to the element, or a function that
|
|
385
|
+
* returns a style object based on the component's state.
|
|
386
|
+
*/
|
|
387
|
+
style?: React$1.CSSProperties | ((state: State) => React$1.CSSProperties | undefined) | undefined;
|
|
388
|
+
};
|
|
389
|
+
interface NativeButtonProps {
|
|
390
|
+
/**
|
|
391
|
+
* Whether the component renders a native `<button>` element when replacing it
|
|
392
|
+
* via the `render` prop.
|
|
393
|
+
* Set to `false` if the rendered element is not a button (for example, `<div>`).
|
|
394
|
+
* @default true
|
|
395
|
+
*/
|
|
396
|
+
nativeButton?: boolean | undefined;
|
|
397
|
+
}
|
|
398
|
+
interface NonNativeButtonProps {
|
|
399
|
+
/**
|
|
400
|
+
* Whether the component renders a native `<button>` element when replacing it
|
|
401
|
+
* via the `render` prop.
|
|
402
|
+
* Set to `true` if the rendered element is a native button.
|
|
403
|
+
* @default false
|
|
404
|
+
*/
|
|
405
|
+
nativeButton?: boolean | undefined;
|
|
406
|
+
}
|
|
407
|
+
type Orientation = 'horizontal' | 'vertical';
|
|
408
|
+
//#endregion
|
|
409
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/internals/getStateAttributesProps.d.mts
|
|
410
|
+
type StateAttributesMapping<State> = { [Property in keyof State]?: (state: State[Property]) => Record<string, string> | null; };
|
|
411
|
+
//#endregion
|
|
412
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/use-render/useRender.d.mts
|
|
413
|
+
/**
|
|
414
|
+
* Renders a Base UI element.
|
|
415
|
+
*
|
|
416
|
+
* @public
|
|
417
|
+
*/
|
|
418
|
+
declare function useRender<State extends Record<string, unknown>, RenderedElementType extends Element, Enabled extends boolean | undefined = undefined>(params: useRender.Parameters<State, RenderedElementType, Enabled>): useRender.ReturnValue<Enabled>;
|
|
419
|
+
type UseRenderRenderProp<State = Record<string, unknown>> = React$1.ReactElement | ComponentRenderFn<React$1.HTMLAttributes<any>, State>;
|
|
420
|
+
type UseRenderElementProps<ElementType extends React$1.ElementType> = React$1.ComponentPropsWithRef<ElementType>;
|
|
421
|
+
type UseRenderComponentProps<ElementType extends React$1.ElementType, State = {}, RenderFunctionProps = HTMLProps> = React$1.ComponentPropsWithRef<ElementType> & {
|
|
422
|
+
/**
|
|
423
|
+
* Allows you to replace the component's HTML element
|
|
424
|
+
* with a different tag, or compose it with another component.
|
|
425
|
+
*
|
|
426
|
+
* Accepts a `ReactElement` or a function that returns the element to render.
|
|
427
|
+
*/
|
|
428
|
+
render?: React$1.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
|
|
429
|
+
};
|
|
430
|
+
interface UseRenderParameters<State, RenderedElementType extends Element, Enabled extends boolean | undefined> {
|
|
431
|
+
/**
|
|
432
|
+
* The React element or a function that returns one to override the default element.
|
|
433
|
+
*/
|
|
434
|
+
render?: UseRenderRenderProp<State> | undefined;
|
|
435
|
+
/**
|
|
436
|
+
* The ref to apply to the rendered element.
|
|
437
|
+
*/
|
|
438
|
+
ref?: React$1.Ref<RenderedElementType> | React$1.Ref<RenderedElementType>[] | undefined;
|
|
439
|
+
/**
|
|
440
|
+
* The state of the component, passed as the second argument to the `render` callback.
|
|
441
|
+
* State properties are automatically converted to data-* attributes.
|
|
442
|
+
*/
|
|
443
|
+
state?: State | undefined;
|
|
444
|
+
/**
|
|
445
|
+
* Custom mapping for converting state properties to data-* attributes.
|
|
446
|
+
* @example
|
|
447
|
+
* { isActive: (value) => (value ? { 'data-is-active': '' } : null) }
|
|
448
|
+
*/
|
|
449
|
+
stateAttributesMapping?: StateAttributesMapping<State> | undefined;
|
|
450
|
+
/**
|
|
451
|
+
* Props to be spread on the rendered element.
|
|
452
|
+
* They are merged with the internal props of the component, so that event handlers
|
|
453
|
+
* are merged, `className` strings and `style` properties are joined, while other external props overwrite the
|
|
454
|
+
* internal ones.
|
|
455
|
+
*/
|
|
456
|
+
props?: Record<string, unknown> | undefined;
|
|
457
|
+
/**
|
|
458
|
+
* If `false`, the hook will skip most of its internal logic and return `null`.
|
|
459
|
+
* This is useful for rendering a component conditionally.
|
|
460
|
+
* @default true
|
|
461
|
+
*/
|
|
462
|
+
enabled?: Enabled | undefined;
|
|
463
|
+
/**
|
|
464
|
+
* The default tag name to use for the rendered element when `render` is not provided.
|
|
465
|
+
* @default 'div'
|
|
466
|
+
*/
|
|
467
|
+
defaultTagName?: keyof React$1.JSX.IntrinsicElements | undefined;
|
|
468
|
+
}
|
|
469
|
+
type UseRenderReturnValue<Enabled extends boolean | undefined> = Enabled extends false ? null : React$1.ReactElement;
|
|
470
|
+
interface UseRenderState {}
|
|
471
|
+
declare namespace useRender {
|
|
472
|
+
type State = UseRenderState;
|
|
473
|
+
type RenderProp<TState = Record<string, unknown>> = UseRenderRenderProp<TState>;
|
|
474
|
+
type ElementProps<ElementType extends React$1.ElementType> = UseRenderElementProps<ElementType>;
|
|
475
|
+
type ComponentProps<ElementType extends React$1.ElementType, TState = {}, RenderFunctionProps = HTMLProps> = UseRenderComponentProps<ElementType, TState, RenderFunctionProps>;
|
|
476
|
+
type Parameters<TState, RenderedElementType extends Element, Enabled extends boolean | undefined> = UseRenderParameters<TState, RenderedElementType, Enabled>;
|
|
477
|
+
type ReturnValue<Enabled extends boolean | undefined> = UseRenderReturnValue<Enabled>;
|
|
478
|
+
}
|
|
479
|
+
//#endregion
|
|
480
|
+
//#region dashboard/components/ui/badge.d.ts
|
|
481
|
+
declare const badgeVariants: (props?: ({
|
|
482
|
+
variant?: "default" | "secondary" | "destructive" | "outline" | "ghost" | "link" | null | undefined;
|
|
483
|
+
} & import("class-variance-authority/types").ClassProp) | undefined) => string;
|
|
484
|
+
declare function Badge({ className, variant, render, ...props }: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
|
|
485
|
+
//#endregion
|
|
486
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/button/Button.d.mts
|
|
487
|
+
/**
|
|
488
|
+
* A button component that can be used to trigger actions.
|
|
489
|
+
* Renders a `<button>` element.
|
|
490
|
+
*
|
|
491
|
+
* Documentation: [Base UI Button](https://base-ui.com/react/components/button)
|
|
492
|
+
*/
|
|
493
|
+
declare const Button$1: React$1.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLElement>>;
|
|
494
|
+
interface ButtonState {
|
|
495
|
+
/**
|
|
496
|
+
* Whether the button should ignore user interaction.
|
|
497
|
+
*/
|
|
498
|
+
disabled: boolean;
|
|
499
|
+
}
|
|
500
|
+
interface ButtonProps extends NativeButtonProps, BaseUIComponentProps<'button', ButtonState> {
|
|
501
|
+
/**
|
|
502
|
+
* Whether the button should be focusable when disabled.
|
|
503
|
+
* @default false
|
|
504
|
+
*/
|
|
505
|
+
focusableWhenDisabled?: boolean | undefined;
|
|
506
|
+
}
|
|
507
|
+
declare namespace Button$1 {
|
|
508
|
+
type State = ButtonState;
|
|
509
|
+
type Props = ButtonProps;
|
|
510
|
+
}
|
|
511
|
+
//#endregion
|
|
512
|
+
//#region dashboard/components/ui/button.d.ts
|
|
513
|
+
declare const buttonVariants: (props?: ({
|
|
514
|
+
variant?: "default" | "secondary" | "destructive" | "outline" | "ghost" | "link" | null | undefined;
|
|
515
|
+
size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
|
|
516
|
+
} & import("class-variance-authority/types").ClassProp) | undefined) => string;
|
|
517
|
+
declare function Button({ className, variant, size, ...props }: Button$1.Props & VariantProps<typeof buttonVariants>): import("react").JSX.Element;
|
|
518
|
+
//#endregion
|
|
519
|
+
//#region dashboard/components/ui/card.d.ts
|
|
520
|
+
declare function Card({ className, size, ...props }: React$1.ComponentProps<"div"> & {
|
|
521
|
+
size?: "default" | "sm";
|
|
522
|
+
}): React$1.JSX.Element;
|
|
523
|
+
declare function CardHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
|
|
524
|
+
declare function CardTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
|
|
525
|
+
declare function CardDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
|
|
526
|
+
declare function CardAction({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
|
|
527
|
+
declare function CardContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
|
|
528
|
+
declare function CardFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
|
|
529
|
+
//#endregion
|
|
530
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/field/root/FieldRoot.d.mts
|
|
531
|
+
interface FieldRootState {
|
|
532
|
+
/**
|
|
533
|
+
* Whether the component should ignore user interaction.
|
|
534
|
+
*/
|
|
535
|
+
disabled: boolean;
|
|
536
|
+
/**
|
|
537
|
+
* Whether the field has been touched.
|
|
538
|
+
*/
|
|
539
|
+
touched: boolean;
|
|
540
|
+
/**
|
|
541
|
+
* Whether the field value has changed from its initial value.
|
|
542
|
+
*/
|
|
543
|
+
dirty: boolean;
|
|
544
|
+
/**
|
|
545
|
+
* Whether the field is valid.
|
|
546
|
+
*/
|
|
547
|
+
valid: boolean | null;
|
|
548
|
+
/**
|
|
549
|
+
* Whether the field has a value.
|
|
550
|
+
*/
|
|
551
|
+
filled: boolean;
|
|
552
|
+
/**
|
|
553
|
+
* Whether the field is focused.
|
|
554
|
+
*/
|
|
555
|
+
focused: boolean;
|
|
556
|
+
}
|
|
557
|
+
//#endregion
|
|
558
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/checkbox/root/CheckboxRoot.d.mts
|
|
559
|
+
/**
|
|
560
|
+
* Represents the checkbox itself.
|
|
561
|
+
* Renders a `<span>` element and a hidden `<input>` beside.
|
|
562
|
+
*
|
|
563
|
+
* Documentation: [Base UI Checkbox](https://base-ui.com/react/components/checkbox)
|
|
564
|
+
*/
|
|
565
|
+
declare const CheckboxRoot: React$1.ForwardRefExoticComponent<Omit<CheckboxRootProps, "ref"> & React$1.RefAttributes<HTMLElement>>;
|
|
566
|
+
interface CheckboxRootState extends FieldRootState {
|
|
567
|
+
/**
|
|
568
|
+
* Whether the checkbox is currently ticked.
|
|
569
|
+
*/
|
|
570
|
+
checked: boolean;
|
|
571
|
+
/**
|
|
572
|
+
* Whether the component should ignore user interaction.
|
|
573
|
+
*/
|
|
574
|
+
disabled: boolean;
|
|
575
|
+
/**
|
|
576
|
+
* Whether the user should be unable to tick or untick the checkbox.
|
|
577
|
+
*/
|
|
578
|
+
readOnly: boolean;
|
|
579
|
+
/**
|
|
580
|
+
* Whether the user must tick the checkbox before submitting a form.
|
|
581
|
+
*/
|
|
582
|
+
required: boolean;
|
|
583
|
+
/**
|
|
584
|
+
* Whether the checkbox is in a mixed state: neither ticked, nor unticked.
|
|
585
|
+
*/
|
|
586
|
+
indeterminate: boolean;
|
|
587
|
+
}
|
|
588
|
+
interface CheckboxRootProps extends NonNativeButtonProps, Omit<BaseUIComponentProps<'span', CheckboxRootState>, 'onChange' | 'value'> {
|
|
589
|
+
/**
|
|
590
|
+
* The id of the input element.
|
|
591
|
+
*/
|
|
592
|
+
id?: string | undefined;
|
|
593
|
+
/**
|
|
594
|
+
* Identifies the field when a form is submitted.
|
|
595
|
+
* @default undefined
|
|
596
|
+
*/
|
|
597
|
+
name?: string | undefined;
|
|
598
|
+
/**
|
|
599
|
+
* Identifies the form that owns the hidden input.
|
|
600
|
+
* Useful when the checkbox is rendered outside the form.
|
|
601
|
+
*/
|
|
602
|
+
form?: string | undefined;
|
|
603
|
+
/**
|
|
604
|
+
* Whether the checkbox is currently ticked.
|
|
605
|
+
*
|
|
606
|
+
* To render an uncontrolled checkbox, use the `defaultChecked` prop instead.
|
|
607
|
+
* @default undefined
|
|
608
|
+
*/
|
|
609
|
+
checked?: boolean | undefined;
|
|
610
|
+
/**
|
|
611
|
+
* Whether the checkbox is initially ticked.
|
|
612
|
+
*
|
|
613
|
+
* To render a controlled checkbox, use the `checked` prop instead.
|
|
614
|
+
* @default false
|
|
615
|
+
*/
|
|
616
|
+
defaultChecked?: boolean | undefined;
|
|
617
|
+
/**
|
|
618
|
+
* Whether the component should ignore user interaction.
|
|
619
|
+
* @default false
|
|
620
|
+
*/
|
|
621
|
+
disabled?: boolean | undefined;
|
|
622
|
+
/**
|
|
623
|
+
* Event handler called when the checkbox is ticked or unticked.
|
|
624
|
+
*/
|
|
625
|
+
onCheckedChange?: ((checked: boolean, eventDetails: CheckboxRootChangeEventDetails) => void) | undefined;
|
|
626
|
+
/**
|
|
627
|
+
* Whether the user should be unable to tick or untick the checkbox.
|
|
628
|
+
* @default false
|
|
629
|
+
*/
|
|
630
|
+
readOnly?: boolean | undefined;
|
|
631
|
+
/**
|
|
632
|
+
* Whether the user must tick the checkbox before submitting a form.
|
|
633
|
+
* @default false
|
|
634
|
+
*/
|
|
635
|
+
required?: boolean | undefined;
|
|
636
|
+
/**
|
|
637
|
+
* Whether the checkbox is in a mixed state: neither ticked, nor unticked.
|
|
638
|
+
* @default false
|
|
639
|
+
*/
|
|
640
|
+
indeterminate?: boolean | undefined;
|
|
641
|
+
/**
|
|
642
|
+
* A ref to access the hidden `<input>` element.
|
|
643
|
+
*/
|
|
644
|
+
inputRef?: React$1.Ref<HTMLInputElement> | undefined;
|
|
645
|
+
/**
|
|
646
|
+
* Whether the checkbox controls a group of child checkboxes.
|
|
647
|
+
*
|
|
648
|
+
* Must be used in a [Checkbox Group](https://base-ui.com/react/components/checkbox-group).
|
|
649
|
+
* @default false
|
|
650
|
+
*/
|
|
651
|
+
parent?: boolean | undefined;
|
|
652
|
+
/**
|
|
653
|
+
* The value submitted with the form when the checkbox is unchecked.
|
|
654
|
+
* By default, unchecked checkboxes do not submit any value, matching native checkbox behavior.
|
|
655
|
+
*/
|
|
656
|
+
uncheckedValue?: string | undefined;
|
|
657
|
+
/**
|
|
658
|
+
* The checkbox's value. Identifies it within a [Checkbox Group](https://base-ui.com/react/components/checkbox-group), falling back to `name` when omitted.
|
|
659
|
+
* When submitting a form, a checked box submits `value`; with no `value`, it submits the native "on".
|
|
660
|
+
*/
|
|
661
|
+
value?: string | undefined;
|
|
662
|
+
}
|
|
663
|
+
type CheckboxRootChangeEventReason = typeof none;
|
|
664
|
+
type CheckboxRootChangeEventDetails = BaseUIChangeEventDetails<CheckboxRoot.ChangeEventReason>;
|
|
665
|
+
declare namespace CheckboxRoot {
|
|
666
|
+
type State = CheckboxRootState;
|
|
667
|
+
type Props = CheckboxRootProps;
|
|
668
|
+
type ChangeEventReason = CheckboxRootChangeEventReason;
|
|
669
|
+
type ChangeEventDetails = CheckboxRootChangeEventDetails;
|
|
670
|
+
}
|
|
671
|
+
//#endregion
|
|
672
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/internals/useTransitionStatus.d.mts
|
|
673
|
+
type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
|
|
674
|
+
//#endregion
|
|
675
|
+
//#region dashboard/components/ui/checkbox.d.ts
|
|
676
|
+
declare function Checkbox({ className, ...props }: CheckboxRoot.Props): import("react").JSX.Element;
|
|
677
|
+
//#endregion
|
|
678
|
+
//#region dashboard/components/ui/input.d.ts
|
|
679
|
+
declare function Input({ className, type, ...props }: React$1.ComponentProps<"input">): React$1.JSX.Element;
|
|
680
|
+
//#endregion
|
|
681
|
+
//#region dashboard/components/ui/kbd.d.ts
|
|
682
|
+
declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): import("react").JSX.Element;
|
|
683
|
+
declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
|
|
684
|
+
//#endregion
|
|
685
|
+
//#region ../../node_modules/.bun/@floating-ui+utils@0.2.12/node_modules/@floating-ui/utils/dist/floating-ui.utils.d.mts
|
|
686
|
+
declare type AlignedPlacement = `${Side$1}-${Alignment}`;
|
|
687
|
+
declare type Alignment = 'start' | 'end';
|
|
688
|
+
declare type Axis = 'x' | 'y';
|
|
689
|
+
declare type ClientRectObject = Prettify$1<Rect & SideObject>;
|
|
690
|
+
declare type Coords = { [key in Axis]: number; };
|
|
691
|
+
declare type Dimensions = { [key in Length]: number; };
|
|
692
|
+
declare type Length = 'width' | 'height';
|
|
693
|
+
declare type Padding = number | Prettify$1<{ [K in Side$1]?: number | undefined; }>;
|
|
694
|
+
declare type Placement$1 = Prettify$1<Side$1 | AlignedPlacement>;
|
|
695
|
+
declare type Prettify$1<T> = { [K in keyof T]: T[K]; } & {};
|
|
696
|
+
declare type Rect = Prettify$1<Coords & Dimensions>;
|
|
697
|
+
declare type Side$1 = 'top' | 'right' | 'bottom' | 'left';
|
|
698
|
+
declare type SideObject = { [key in Side$1]: number; };
|
|
699
|
+
declare type Strategy = 'absolute' | 'fixed';
|
|
700
|
+
//#endregion
|
|
701
|
+
//#region ../../node_modules/.bun/@floating-ui+core@1.8.0/node_modules/@floating-ui/core/dist/floating-ui.core.d.mts
|
|
702
|
+
declare interface ComputePositionReturn extends Coords {
|
|
703
|
+
/**
|
|
704
|
+
* The final chosen placement of the floating element.
|
|
705
|
+
*/
|
|
706
|
+
placement: Placement$1;
|
|
707
|
+
/**
|
|
708
|
+
* The strategy used to position the floating element.
|
|
709
|
+
*/
|
|
710
|
+
strategy: Strategy;
|
|
711
|
+
/**
|
|
712
|
+
* Object containing data returned from all middleware, keyed by their name.
|
|
713
|
+
*/
|
|
714
|
+
middlewareData: MiddlewareData;
|
|
715
|
+
}
|
|
716
|
+
declare interface MiddlewareData {
|
|
717
|
+
[key: string]: any;
|
|
718
|
+
arrow?: (Partial<Coords> & {
|
|
719
|
+
centerOffset: number;
|
|
720
|
+
alignmentOffset?: number | undefined;
|
|
721
|
+
}) | undefined;
|
|
722
|
+
autoPlacement?: {
|
|
723
|
+
index?: number | undefined;
|
|
724
|
+
overflows: Array<{
|
|
725
|
+
placement: Placement$1;
|
|
726
|
+
overflows: Array<number>;
|
|
727
|
+
}>;
|
|
728
|
+
} | undefined;
|
|
729
|
+
flip?: {
|
|
730
|
+
index?: number | undefined;
|
|
731
|
+
overflows: Array<{
|
|
732
|
+
placement: Placement$1;
|
|
733
|
+
overflows: Array<number>;
|
|
734
|
+
}>;
|
|
735
|
+
} | undefined;
|
|
736
|
+
hide?: {
|
|
737
|
+
referenceHidden?: boolean | undefined;
|
|
738
|
+
escaped?: boolean | undefined;
|
|
739
|
+
referenceHiddenOffsets?: SideObject | undefined;
|
|
740
|
+
escapedOffsets?: SideObject | undefined;
|
|
741
|
+
} | undefined;
|
|
742
|
+
offset?: (Coords & {
|
|
743
|
+
placement: Placement$1;
|
|
744
|
+
}) | undefined;
|
|
745
|
+
shift?: (Coords & {
|
|
746
|
+
enabled: { [key in Axis]: boolean; };
|
|
747
|
+
}) | undefined;
|
|
748
|
+
}
|
|
749
|
+
//#endregion
|
|
750
|
+
//#region ../../node_modules/.bun/@floating-ui+dom@1.8.0/node_modules/@floating-ui/dom/dist/floating-ui.dom.d.mts
|
|
751
|
+
/**
|
|
752
|
+
* Custom positioning reference element.
|
|
753
|
+
* @see https://floating-ui.com/docs/virtual-elements
|
|
754
|
+
*/
|
|
755
|
+
declare interface VirtualElement {
|
|
756
|
+
getBoundingClientRect(): ClientRectObject;
|
|
757
|
+
getClientRects?: (() => Array<ClientRectObject> | DOMRectList) | undefined;
|
|
758
|
+
contextElement?: Element | undefined;
|
|
759
|
+
}
|
|
760
|
+
//#endregion
|
|
761
|
+
//#region ../../node_modules/.bun/@floating-ui+react-dom@2.1.9+ab9c01e4ccdf52df/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.d.mts
|
|
762
|
+
declare type Prettify<T> = { [K in keyof T]: T[K]; } & {};
|
|
763
|
+
declare type ReferenceType$1 = Element | VirtualElement;
|
|
764
|
+
declare type UseFloatingData = Prettify<ComputePositionReturn & {
|
|
765
|
+
isPositioned: boolean;
|
|
766
|
+
}>;
|
|
767
|
+
declare type UseFloatingReturn<RT extends ReferenceType$1 = ReferenceType$1> = Prettify<UseFloatingData & {
|
|
768
|
+
/**
|
|
769
|
+
* Update the position of the floating element, re-rendering the component
|
|
770
|
+
* if required.
|
|
771
|
+
*/
|
|
772
|
+
update: () => void;
|
|
773
|
+
/**
|
|
774
|
+
* Pre-configured positioning styles to apply to the floating element.
|
|
775
|
+
*/
|
|
776
|
+
floatingStyles: React$1.CSSProperties;
|
|
777
|
+
/**
|
|
778
|
+
* Object containing the reference and floating refs and reactive setters.
|
|
779
|
+
*/
|
|
780
|
+
refs: {
|
|
781
|
+
/**
|
|
782
|
+
* A React ref to the reference element.
|
|
783
|
+
*/
|
|
784
|
+
reference: React$1.MutableRefObject<RT | null>;
|
|
785
|
+
/**
|
|
786
|
+
* A React ref to the floating element.
|
|
787
|
+
*/
|
|
788
|
+
floating: React$1.MutableRefObject<HTMLElement | null>;
|
|
789
|
+
/**
|
|
790
|
+
* A callback to set the reference element (reactive).
|
|
791
|
+
*/
|
|
792
|
+
setReference: (node: RT | null) => void;
|
|
793
|
+
/**
|
|
794
|
+
* A callback to set the floating element (reactive).
|
|
795
|
+
*/
|
|
796
|
+
setFloating: (node: HTMLElement | null) => void;
|
|
797
|
+
};
|
|
798
|
+
/**
|
|
799
|
+
* Object containing the reference and floating elements.
|
|
800
|
+
*/
|
|
801
|
+
elements: {
|
|
802
|
+
reference: RT | null;
|
|
803
|
+
floating: HTMLElement | null;
|
|
804
|
+
};
|
|
805
|
+
}>;
|
|
806
|
+
//#endregion
|
|
807
|
+
//#region ../../node_modules/.bun/@base-ui+utils@0.5.0+2fde69a3fd50c568/node_modules/@base-ui/utils/store/Store.d.mts
|
|
808
|
+
type Listener<T> = (state: T) => void;
|
|
809
|
+
/**
|
|
810
|
+
* A data store implementation that allows subscribing to state changes and updating the state.
|
|
811
|
+
* It uses an observer pattern to notify subscribers when the state changes.
|
|
812
|
+
*/
|
|
813
|
+
declare class Store<State> {
|
|
814
|
+
/**
|
|
815
|
+
* Creates a store with the given initial state, constructing the class it is called on.
|
|
816
|
+
* Calling it on a generic base class (e.g. `ReactStore.create(...)`) constructs that
|
|
817
|
+
* class but degrades the inferred instance type to `Store`; use `new` there instead.
|
|
818
|
+
*/
|
|
819
|
+
static create<T, This extends Store<T>>(this: new (state: T) => This, state: T): This;
|
|
820
|
+
/**
|
|
821
|
+
* The current state of the store.
|
|
822
|
+
* This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
|
|
823
|
+
* To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
|
|
824
|
+
* The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
|
|
825
|
+
*
|
|
826
|
+
* Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
|
|
827
|
+
*/
|
|
828
|
+
state: State;
|
|
829
|
+
private listeners;
|
|
830
|
+
private updateTick;
|
|
831
|
+
constructor(state: State);
|
|
832
|
+
/**
|
|
833
|
+
* Registers a listener that will be called whenever the store's state changes.
|
|
834
|
+
*
|
|
835
|
+
* @param fn The listener function to be called on state changes.
|
|
836
|
+
* @returns A function to unsubscribe the listener.
|
|
837
|
+
*/
|
|
838
|
+
subscribe: (fn: Listener<State>) => () => void;
|
|
839
|
+
/**
|
|
840
|
+
* Returns the current state of the store.
|
|
841
|
+
*/
|
|
842
|
+
getSnapshot: () => State;
|
|
843
|
+
/**
|
|
844
|
+
* Updates the entire store's state and notifies all registered listeners.
|
|
845
|
+
*
|
|
846
|
+
* @param newState The new state to set for the store.
|
|
847
|
+
*/
|
|
848
|
+
setState(newState: State): void;
|
|
849
|
+
/**
|
|
850
|
+
* Merges the provided changes into the current state and notifies listeners if there are changes.
|
|
851
|
+
* Each value must match its state key. Pass an exact known subset rather than a broad
|
|
852
|
+
* `Partial<State>`, which may contain `undefined` for required state fields.
|
|
853
|
+
*
|
|
854
|
+
* @param changes An object containing the changes to apply to the current state.
|
|
855
|
+
*/
|
|
856
|
+
update<const Key extends keyof State>(changes: Pick<State, Key>): void;
|
|
857
|
+
/**
|
|
858
|
+
* Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
|
|
859
|
+
*
|
|
860
|
+
* @param key The key in the store's state to update.
|
|
861
|
+
* @param value The new value to set for the specified key.
|
|
862
|
+
*/
|
|
863
|
+
set<Key extends keyof State>(key: Key, value: State[Key]): void;
|
|
864
|
+
/**
|
|
865
|
+
* Gives the state a new reference and updates all registered listeners.
|
|
866
|
+
*/
|
|
867
|
+
notifyAll(): void;
|
|
868
|
+
use<F extends (...args: any) => any>(selector: F, ...args: SelectorArgs$1<F>): ReturnType<F>;
|
|
869
|
+
}
|
|
870
|
+
type SelectorArgs$1<Selector> = Selector extends ((...params: infer Params) => any) ? Tail$1<Params> : never;
|
|
871
|
+
type Tail$1<T extends readonly any[]> = T extends readonly [any, ...infer Rest] ? Rest : [];
|
|
872
|
+
//#endregion
|
|
873
|
+
//#region ../../node_modules/.bun/@base-ui+utils@0.5.0+2fde69a3fd50c568/node_modules/@base-ui/utils/store/ReactStore.d.mts
|
|
874
|
+
/**
|
|
875
|
+
* A Store that supports controlled state keys, non-reactive values and provides utility methods for React.
|
|
876
|
+
*/
|
|
877
|
+
declare class ReactStore<State extends object, Context = Record<string, never>, Selectors extends Record<string, SelectorFunction<State>> = Record<string, never>> extends Store<State> {
|
|
878
|
+
/**
|
|
879
|
+
* Creates a new ReactStore instance.
|
|
880
|
+
*
|
|
881
|
+
* @param state Initial state of the store.
|
|
882
|
+
* @param context Non-reactive context values.
|
|
883
|
+
* @param selectors Optional selectors for use with `useState`.
|
|
884
|
+
*/
|
|
885
|
+
constructor(state: State, context?: Context, selectors?: Selectors);
|
|
886
|
+
/**
|
|
887
|
+
* Non-reactive values such as refs, callbacks, etc.
|
|
888
|
+
*/
|
|
889
|
+
readonly context: Context;
|
|
890
|
+
private selectors;
|
|
891
|
+
/**
|
|
892
|
+
* Synchronizes a single external value into the store.
|
|
893
|
+
*
|
|
894
|
+
* Note that the while the value in `state` is updated immediately, the value returned
|
|
895
|
+
* by `useState` is updated before the next render (similarly to React's `useState`).
|
|
896
|
+
*/
|
|
897
|
+
useSyncedValue<Key extends keyof State>(key: Key, value: State[Key]): void;
|
|
898
|
+
/**
|
|
899
|
+
* Synchronizes a single external value into the store and
|
|
900
|
+
* cleans it up (sets to `undefined`) on unmount.
|
|
901
|
+
*
|
|
902
|
+
* Note that the while the value in `state` is updated immediately, the value returned
|
|
903
|
+
* by `useState` is updated before the next render (similarly to React's `useState`).
|
|
904
|
+
*/
|
|
905
|
+
useSyncedValueWithCleanup<Key extends KeysAllowingUndefined<State>>(key: Key, value: State[Key]): void;
|
|
906
|
+
/**
|
|
907
|
+
* Synchronizes multiple external values into the store.
|
|
908
|
+
* Each value must match its state key. Pass an exact known subset rather than a broad
|
|
909
|
+
* `Partial<State>`, which may contain `undefined` for required state fields.
|
|
910
|
+
*
|
|
911
|
+
* Note that the while the values in `state` are updated immediately, the values returned
|
|
912
|
+
* by `useState` are updated before the next render (similarly to React's `useState`).
|
|
913
|
+
*
|
|
914
|
+
* @param statePart An exact subset of state fields to synchronize. Unknown keys are not accepted.
|
|
915
|
+
*/
|
|
916
|
+
useSyncedValues<const Key extends keyof State>(statePart: Pick<State, Key>): void;
|
|
917
|
+
/**
|
|
918
|
+
* Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
|
|
919
|
+
* is non-undefined, the store's state at `key` is updated to match `controlled`.
|
|
920
|
+
*/
|
|
921
|
+
useControlledProp<Key extends keyof State>(key: Key, controlled: State[Key] | undefined): void;
|
|
922
|
+
/** Gets the current value from the store using a selector with the provided key.
|
|
923
|
+
*
|
|
924
|
+
* @param key Key of the selector to use.
|
|
925
|
+
*/
|
|
926
|
+
select<Key extends keyof Selectors>(key: Key, ...args: SelectorArgs<Selectors[Key]>): ReturnType<Selectors[Key]>;
|
|
927
|
+
/**
|
|
928
|
+
* Returns a value from the store's state using a selector function.
|
|
929
|
+
* Used to subscribe to specific parts of the state.
|
|
930
|
+
* This methods causes a rerender whenever the selected state changes.
|
|
931
|
+
*
|
|
932
|
+
* @param key Key of the selector to use.
|
|
933
|
+
*/
|
|
934
|
+
useState<Key extends keyof Selectors>(key: Key, ...args: SelectorArgs<Selectors[Key]>): ReturnType<Selectors[Key]>;
|
|
935
|
+
/**
|
|
936
|
+
* Wraps a function with `useStableCallback` to ensure it has a stable reference
|
|
937
|
+
* and assigns it to the context.
|
|
938
|
+
*
|
|
939
|
+
* @param key Key of the event callback. Must be a function in the context.
|
|
940
|
+
* @param fn Function to assign.
|
|
941
|
+
*/
|
|
942
|
+
useContextCallback<Key extends ContextFunctionKeys<Context>>(key: Key, fn: ContextFunction<Context, Key> | undefined): void;
|
|
943
|
+
/**
|
|
944
|
+
* Returns a stable setter function for a specific key in the store's state.
|
|
945
|
+
* It's commonly used to pass as a ref callback to React elements.
|
|
946
|
+
*
|
|
947
|
+
* @param key Key of the state to set.
|
|
948
|
+
*/
|
|
949
|
+
useStateSetter<const Key extends keyof State>(key: Key): (value: State[Key]) => void;
|
|
950
|
+
/**
|
|
951
|
+
* Observes changes derived from the store's selectors and calls the listener when the selected value changes.
|
|
952
|
+
*
|
|
953
|
+
* @param key Key of the selector to observe.
|
|
954
|
+
* @param listener Listener function called when the selector result changes.
|
|
955
|
+
*/
|
|
956
|
+
observe<Key extends keyof Selectors>(selector: Key, listener: (newValue: ReturnType<Selectors[Key]>, oldValue: ReturnType<Selectors[Key]>, store: this) => void): () => void;
|
|
957
|
+
observe<Selector extends ObserveSelector<State>>(selector: Selector, listener: (newValue: ReturnType<Selector>, oldValue: ReturnType<Selector>, store: this) => void): () => void;
|
|
958
|
+
}
|
|
959
|
+
type MaybeCallable = (...args: any[]) => any;
|
|
960
|
+
type ContextFunctionKeys<Context> = { [Key in keyof Context]-?: Extract<Context[Key], MaybeCallable> extends never ? never : Key; }[keyof Context];
|
|
961
|
+
type ContextFunction<Context, Key extends keyof Context> = Extract<Context[Key], MaybeCallable>;
|
|
962
|
+
type KeysAllowingUndefined<State> = { [Key in keyof State]-?: undefined extends State[Key] ? Key : never; }[keyof State];
|
|
963
|
+
type ObserveSelector<State> = (state: State) => any;
|
|
964
|
+
type SelectorFunction<State> = (state: State, ...args: any[]) => any;
|
|
965
|
+
type Tail<T extends readonly any[]> = T extends readonly [any, ...infer Rest] ? Rest : [];
|
|
966
|
+
type SelectorArgs<Selector> = Selector extends ((...params: infer Params) => any) ? Tail<Params> : never;
|
|
967
|
+
//#endregion
|
|
968
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/utils/popups/popupTriggerMap.d.mts
|
|
969
|
+
/**
|
|
970
|
+
* Data structure to keep track of popup trigger elements by their IDs.
|
|
971
|
+
*
|
|
972
|
+
* Element lookups iterate the id map rather than maintaining a parallel Set. Registration is O(1),
|
|
973
|
+
* while `hasElement` and `hasMatchingElement` are linear in the number of triggers.
|
|
974
|
+
*/
|
|
975
|
+
declare class PopupTriggerMap {
|
|
976
|
+
private idMap;
|
|
977
|
+
/**
|
|
978
|
+
* Adds a trigger element with the given ID.
|
|
979
|
+
*
|
|
980
|
+
* Note: The provided element is assumed to not be registered under multiple IDs.
|
|
981
|
+
*/
|
|
982
|
+
add(id: string, element: Element): void;
|
|
983
|
+
/**
|
|
984
|
+
* Removes the trigger element with the given ID.
|
|
985
|
+
*/
|
|
986
|
+
delete(id: string): void;
|
|
987
|
+
/**
|
|
988
|
+
* Whether the given element is registered as a trigger.
|
|
989
|
+
*/
|
|
990
|
+
hasElement(element: Element): boolean;
|
|
991
|
+
/**
|
|
992
|
+
* Whether there is a registered trigger element matching the given predicate.
|
|
993
|
+
*/
|
|
994
|
+
hasMatchingElement(predicate: (el: Element) => boolean): boolean;
|
|
995
|
+
/**
|
|
996
|
+
* Returns the trigger element associated with the given ID, or undefined if no such element exists.
|
|
997
|
+
*/
|
|
998
|
+
getById(id: string): Element | undefined;
|
|
999
|
+
/**
|
|
1000
|
+
* Returns an iterable of all registered trigger entries, where each entry is a tuple of [id, element].
|
|
1001
|
+
*/
|
|
1002
|
+
entries(): IterableIterator<[string, Element]>;
|
|
1003
|
+
/**
|
|
1004
|
+
* Returns an iterable of all registered trigger elements.
|
|
1005
|
+
*/
|
|
1006
|
+
elements(): IterableIterator<Element>;
|
|
1007
|
+
/**
|
|
1008
|
+
* Returns the number of registered trigger elements.
|
|
1009
|
+
*/
|
|
1010
|
+
get size(): number;
|
|
1011
|
+
}
|
|
1012
|
+
//#endregion
|
|
1013
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/utils/popups/popupHandle.d.mts
|
|
1014
|
+
/**
|
|
1015
|
+
* Store shape holding a trigger registry, required by `BasePopupHandle.openByTrigger` to resolve a
|
|
1016
|
+
* trigger element by id on both the attached root's store and the fallback store.
|
|
1017
|
+
*/
|
|
1018
|
+
interface PopupHandleStoreWithTriggers {
|
|
1019
|
+
readonly context: {
|
|
1020
|
+
readonly triggerElements: PopupTriggerMap;
|
|
1021
|
+
};
|
|
1022
|
+
}
|
|
1023
|
+
/**
|
|
1024
|
+
* Store shape required by `BasePopupHandle.openByTrigger`/`closePopup` to drive open/close state.
|
|
1025
|
+
* Only the root-owned `Store` needs this — the `HandleStore` view exposed to detached triggers may
|
|
1026
|
+
* omit `setOpen` entirely (as Dialog and PreviewCard's do) since it is never called while detached.
|
|
1027
|
+
*/
|
|
1028
|
+
interface PopupHandleStoreWithOpen extends PopupHandleStoreWithTriggers {
|
|
1029
|
+
setOpen(open: boolean, eventDetails: BaseUIChangeEventDetails<typeof imperativeAction>): void;
|
|
1030
|
+
}
|
|
1031
|
+
/**
|
|
1032
|
+
* Shared implementation for popup handles that coordinate detached triggers with a mounted root.
|
|
1033
|
+
*
|
|
1034
|
+
* Subclasses provide the component-specific imperative methods, while this base class owns the
|
|
1035
|
+
* fallback store, root store attachment stack, subscriber notifications, and development warning for
|
|
1036
|
+
* overlapping roots.
|
|
1037
|
+
*
|
|
1038
|
+
* @template HandleStore Store shape exposed to detached triggers.
|
|
1039
|
+
* @template Store Root-owned store attached by the component root.
|
|
1040
|
+
*/
|
|
1041
|
+
declare class BasePopupHandle<HandleStore extends PopupHandleStoreWithTriggers, Store extends HandleStore & PopupHandleStoreWithOpen> {
|
|
1042
|
+
protected readonly fallbackStore: HandleStore;
|
|
1043
|
+
private readonly componentName;
|
|
1044
|
+
private readonly throwOnMissingTrigger;
|
|
1045
|
+
/**
|
|
1046
|
+
* Stores of every root currently using this handle, in attach order. A handle is meant to be used
|
|
1047
|
+
* by a single mounted root, but roots can transiently overlap (e.g. during an animated route
|
|
1048
|
+
* transition), so this stack lets `attachStore`'s cleanup restore the previous root instead of
|
|
1049
|
+
* leaving a still-mounted root uncontrollable when a newer overlapping root detaches first.
|
|
1050
|
+
*/
|
|
1051
|
+
private readonly attachedStores;
|
|
1052
|
+
/**
|
|
1053
|
+
* Store of the root that currently controls the handle: the most recently attached one still
|
|
1054
|
+
* mounted, or `null` when no root is attached. Imperative methods are no-ops while this is `null`.
|
|
1055
|
+
*/
|
|
1056
|
+
private attachedStoreValue;
|
|
1057
|
+
/**
|
|
1058
|
+
* Listeners notified when `attachedStore` changes, so detached triggers can follow the store pointer.
|
|
1059
|
+
*/
|
|
1060
|
+
private readonly storeListeners;
|
|
1061
|
+
/**
|
|
1062
|
+
* Creates a handle backed by the store used while no root is attached.
|
|
1063
|
+
*
|
|
1064
|
+
* @param fallbackStore Inert, closed store handed to detached triggers while no root is attached,
|
|
1065
|
+
* so they can render and register without a mounted root. Triggers register into whichever store
|
|
1066
|
+
* `store` currently resolves to, so while detached they live in this store's trigger map and
|
|
1067
|
+
* migrate themselves to the root's store (and back) as it attaches/detaches.
|
|
1068
|
+
* @param componentName Component name used to prefix dev warnings, e.g. `'Menu'` produces
|
|
1069
|
+
* `MenuHandle.open()` in warning text.
|
|
1070
|
+
* @param throwOnMissingTrigger Whether `open(triggerId)` throws when no trigger with that id is
|
|
1071
|
+
* registered. Anchored popups (Menu, Popover, Tooltip, PreviewCard) need a trigger to anchor to,
|
|
1072
|
+
* so they throw; Dialog is not anchored and instead opens unassociated with a dev warning.
|
|
1073
|
+
*/
|
|
1074
|
+
constructor(fallbackStore: HandleStore, componentName: string, throwOnMissingTrigger?: boolean);
|
|
1075
|
+
protected get attachedStore(): Store | null;
|
|
1076
|
+
/**
|
|
1077
|
+
* Sets the store that currently controls the handle and notifies subscribers when it changes, so
|
|
1078
|
+
* detached triggers re-render and migrate their registration to the new store.
|
|
1079
|
+
*/
|
|
1080
|
+
private setActiveStore;
|
|
1081
|
+
/**
|
|
1082
|
+
* Opens the attached root's store and associates it with the trigger with the given id, or a
|
|
1083
|
+
* no-op (with a dev warning) while no root is attached. Shared by every concrete handle's public
|
|
1084
|
+
* `open()` method, which only narrows the parameter type.
|
|
1085
|
+
*
|
|
1086
|
+
* When a trigger id is given but no matching trigger is registered, anchored popups throw (see
|
|
1087
|
+
* `throwOnMissingTrigger`); Dialog opens unassociated with a dev warning instead.
|
|
1088
|
+
*
|
|
1089
|
+
* This method should only be called in an event handler or an effect (not during rendering).
|
|
1090
|
+
*
|
|
1091
|
+
* @param triggerId ID of the trigger to associate with the popup, or `null`/`undefined` to open
|
|
1092
|
+
* without associating any trigger.
|
|
1093
|
+
*/
|
|
1094
|
+
protected openByTrigger(triggerId: string | null | undefined): void;
|
|
1095
|
+
/**
|
|
1096
|
+
* Closes the popup by setting the attached root's store to closed, or a no-op (with a dev warning)
|
|
1097
|
+
* while no root is attached. Shared by every concrete handle's public `close()` method.
|
|
1098
|
+
*
|
|
1099
|
+
* This method should only be called in an event handler or an effect (not during rendering).
|
|
1100
|
+
*/
|
|
1101
|
+
protected closePopup(): void;
|
|
1102
|
+
}
|
|
1103
|
+
//#endregion
|
|
1104
|
+
//#region ../../node_modules/.bun/@base-ui+utils@0.5.0+2fde69a3fd50c568/node_modules/@base-ui/utils/useEnhancedClickHandler.d.mts
|
|
1105
|
+
type InteractionType = 'mouse' | 'touch' | 'pen' | 'keyboard' | '';
|
|
1106
|
+
//#endregion
|
|
1107
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/utils/popups/store.d.mts
|
|
1108
|
+
/**
|
|
1109
|
+
* State common to all popup stores.
|
|
1110
|
+
*/
|
|
1111
|
+
type PopupStoreState<Payload> = {
|
|
1112
|
+
/**
|
|
1113
|
+
* Whether the popup is open (internal state).
|
|
1114
|
+
*/
|
|
1115
|
+
open: boolean;
|
|
1116
|
+
/**
|
|
1117
|
+
* Whether the popup is open (external prop).
|
|
1118
|
+
*/
|
|
1119
|
+
readonly openProp: boolean | undefined;
|
|
1120
|
+
/**
|
|
1121
|
+
* Whether the popup should be mounted in the DOM.
|
|
1122
|
+
* This usually follows `open` but can be different during exit transitions.
|
|
1123
|
+
*/
|
|
1124
|
+
mounted: boolean;
|
|
1125
|
+
/**
|
|
1126
|
+
* The current enter/exit transition status of the popup.
|
|
1127
|
+
*/
|
|
1128
|
+
transitionStatus: TransitionStatus;
|
|
1129
|
+
floatingRootContext: FloatingRootContext;
|
|
1130
|
+
floatingId: string | undefined;
|
|
1131
|
+
/**
|
|
1132
|
+
* Number of trigger elements currently registered for this popup.
|
|
1133
|
+
*/
|
|
1134
|
+
triggerCount: number;
|
|
1135
|
+
/**
|
|
1136
|
+
* Whether to prevent unmounting the popup when closed.
|
|
1137
|
+
* Useful for interacting with JS animation libraries that control unmounting themselves.
|
|
1138
|
+
*/
|
|
1139
|
+
preventUnmountingOnClose: boolean;
|
|
1140
|
+
/**
|
|
1141
|
+
* Optional payload set by the trigger.
|
|
1142
|
+
*/
|
|
1143
|
+
payload: Payload | undefined;
|
|
1144
|
+
/**
|
|
1145
|
+
* ID of the currently active trigger.
|
|
1146
|
+
*/
|
|
1147
|
+
activeTriggerId: string | null;
|
|
1148
|
+
/**
|
|
1149
|
+
* The currently active trigger DOM element.
|
|
1150
|
+
*/
|
|
1151
|
+
activeTriggerElement: Element | null;
|
|
1152
|
+
/**
|
|
1153
|
+
* Whether the popup is open because of a request that deliberately carried no trigger, such as a
|
|
1154
|
+
* handle's `open(null)` or `openWithPayload()`. While set, a lone registered trigger is not
|
|
1155
|
+
* implicitly associated with the popup, so its trigger-owned state (such as `payload`) is not
|
|
1156
|
+
* forwarded. Reset by the Root once the popup is effectively closed.
|
|
1157
|
+
*/
|
|
1158
|
+
openedWithoutTrigger: boolean;
|
|
1159
|
+
/**
|
|
1160
|
+
* ID of the trigger (external prop).
|
|
1161
|
+
*/
|
|
1162
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1163
|
+
/**
|
|
1164
|
+
* The popup DOM element.
|
|
1165
|
+
*/
|
|
1166
|
+
popupElement: HTMLElement | null;
|
|
1167
|
+
/**
|
|
1168
|
+
* The positioner DOM element.
|
|
1169
|
+
*/
|
|
1170
|
+
positionerElement: HTMLElement | null;
|
|
1171
|
+
/**
|
|
1172
|
+
* Props to spread onto the active trigger element.
|
|
1173
|
+
*/
|
|
1174
|
+
activeTriggerProps: HTMLProps;
|
|
1175
|
+
/**
|
|
1176
|
+
* Props to spread onto inactive trigger elements.
|
|
1177
|
+
*/
|
|
1178
|
+
inactiveTriggerProps: HTMLProps;
|
|
1179
|
+
/**
|
|
1180
|
+
* Props to spread onto the popup element.
|
|
1181
|
+
*/
|
|
1182
|
+
popupProps: HTMLProps;
|
|
1183
|
+
};
|
|
1184
|
+
type PopupStoreContext<ChangeEventDetails> = {
|
|
1185
|
+
/**
|
|
1186
|
+
* Map of registered trigger elements.
|
|
1187
|
+
*/
|
|
1188
|
+
readonly triggerElements: PopupTriggerMap;
|
|
1189
|
+
/**
|
|
1190
|
+
* Reference to the popup element.
|
|
1191
|
+
*/
|
|
1192
|
+
readonly popupRef: React.RefObject<HTMLElement | null>;
|
|
1193
|
+
/**
|
|
1194
|
+
* Callback fired when the open state changes.
|
|
1195
|
+
*/
|
|
1196
|
+
onOpenChange?: ((open: boolean, eventDetails: ChangeEventDetails) => void) | undefined;
|
|
1197
|
+
/**
|
|
1198
|
+
* Callback fired when the open state change animation completes.
|
|
1199
|
+
*/
|
|
1200
|
+
onOpenChangeComplete: ((open: boolean) => void) | undefined;
|
|
1201
|
+
};
|
|
1202
|
+
/**
|
|
1203
|
+
* Store members a detached handle-backed trigger reads or invokes for trigger registration and data
|
|
1204
|
+
* forwarding. `set`/`update` are included only for trigger-count and trigger-data bookkeeping; on a
|
|
1205
|
+
* detached (inert) store they are intentionally no-ops, so a write through them is not guaranteed to
|
|
1206
|
+
* be durable. Component handle-store views Pick these from their concrete store (preserving its
|
|
1207
|
+
* context and selectors) and add any component-specific trigger-invoked members such as `setOpen`.
|
|
1208
|
+
*/
|
|
1209
|
+
type PopupTriggerStoreKeys = 'context' | 'select' | 'set' | 'state' | 'update' | 'useState';
|
|
1210
|
+
//#endregion
|
|
1211
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/utils/popups/popupStoreUtils.d.mts
|
|
1212
|
+
type PayloadChildRenderFunction<Payload> = (arg: {
|
|
1213
|
+
payload: Payload | undefined;
|
|
1214
|
+
}) => React$1.ReactNode;
|
|
1215
|
+
//#endregion
|
|
1216
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/floating-ui-react/components/FloatingRootStore.d.mts
|
|
1217
|
+
interface FloatingRootState {
|
|
1218
|
+
open: boolean;
|
|
1219
|
+
transitionStatus: TransitionStatus | undefined;
|
|
1220
|
+
domReferenceElement: Element | null;
|
|
1221
|
+
referenceElement: ReferenceType | null;
|
|
1222
|
+
floatingElement: HTMLElement | null;
|
|
1223
|
+
positionReference: ReferenceType | null;
|
|
1224
|
+
/**
|
|
1225
|
+
* The ID of the floating element.
|
|
1226
|
+
*/
|
|
1227
|
+
floatingId: string | undefined;
|
|
1228
|
+
}
|
|
1229
|
+
interface FloatingRootStoreContext {
|
|
1230
|
+
onOpenChange: ((open: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void) | undefined;
|
|
1231
|
+
readonly dataRef: React$1.RefObject<ContextData>;
|
|
1232
|
+
readonly events: FloatingEvents;
|
|
1233
|
+
nested: boolean;
|
|
1234
|
+
readonly triggerElements: PopupTriggerMap;
|
|
1235
|
+
}
|
|
1236
|
+
declare const selectors$2: {
|
|
1237
|
+
open: (state: FloatingRootState) => boolean;
|
|
1238
|
+
transitionStatus: (state: FloatingRootState) => TransitionStatus;
|
|
1239
|
+
domReferenceElement: (state: FloatingRootState) => Element | null;
|
|
1240
|
+
referenceElement: (state: FloatingRootState) => ReferenceType | null;
|
|
1241
|
+
floatingElement: (state: FloatingRootState) => HTMLElement | null;
|
|
1242
|
+
floatingId: (state: FloatingRootState) => string | undefined;
|
|
1243
|
+
};
|
|
1244
|
+
interface FloatingRootStoreOptions {
|
|
1245
|
+
open: boolean;
|
|
1246
|
+
transitionStatus: TransitionStatus | undefined;
|
|
1247
|
+
referenceElement: ReferenceType | null;
|
|
1248
|
+
floatingElement: HTMLElement | null;
|
|
1249
|
+
triggerElements: PopupTriggerMap;
|
|
1250
|
+
floatingId: string | undefined;
|
|
1251
|
+
/**
|
|
1252
|
+
* When true, `setOpen` only forwards to `onOpenChange`.
|
|
1253
|
+
* The popup store owns `dispatchOpenChange(...)` in this mode.
|
|
1254
|
+
*/
|
|
1255
|
+
syncOnly: boolean;
|
|
1256
|
+
nested: boolean;
|
|
1257
|
+
onOpenChange: ((open: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void) | undefined;
|
|
1258
|
+
}
|
|
1259
|
+
declare class FloatingRootStore extends ReactStore<Readonly<FloatingRootState>, FloatingRootStoreContext, typeof selectors$2> {
|
|
1260
|
+
private readonly syncOnly;
|
|
1261
|
+
constructor(options: FloatingRootStoreOptions);
|
|
1262
|
+
/**
|
|
1263
|
+
* Syncs the event used by hover logic to distinguish hover-open from click-like interaction.
|
|
1264
|
+
*/
|
|
1265
|
+
syncOpenEvent: (newOpen: boolean, event: Event | undefined) => void;
|
|
1266
|
+
/**
|
|
1267
|
+
* Runs the root-owned side effects for an open state change.
|
|
1268
|
+
*/
|
|
1269
|
+
dispatchOpenChange: (newOpen: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void;
|
|
1270
|
+
/**
|
|
1271
|
+
* Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
|
|
1272
|
+
*
|
|
1273
|
+
* @param newOpen The new open state.
|
|
1274
|
+
* @param eventDetails Details about the event that triggered the open state change.
|
|
1275
|
+
*/
|
|
1276
|
+
setOpen: (newOpen: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void;
|
|
1277
|
+
}
|
|
1278
|
+
//#endregion
|
|
1279
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/floating-ui-react/types.d.mts
|
|
1280
|
+
type NarrowedElement<T> = T extends Element ? T : Element;
|
|
1281
|
+
interface ExtendedRefs {
|
|
1282
|
+
reference: React$1.RefObject<ReferenceType | null>;
|
|
1283
|
+
floating: React$1.RefObject<HTMLElement | null>;
|
|
1284
|
+
domReference: React$1.RefObject<NarrowedElement<ReferenceType> | null>;
|
|
1285
|
+
setReference(node: ReferenceType | null): void;
|
|
1286
|
+
setFloating(node: HTMLElement | null): void;
|
|
1287
|
+
setPositionReference(node: ReferenceType | null): void;
|
|
1288
|
+
}
|
|
1289
|
+
interface ExtendedElements {
|
|
1290
|
+
reference: ReferenceType | null;
|
|
1291
|
+
floating: HTMLElement | null;
|
|
1292
|
+
domReference: NarrowedElement<ReferenceType> | null;
|
|
1293
|
+
}
|
|
1294
|
+
interface FloatingEvents {
|
|
1295
|
+
emit<T extends string>(event: T, data?: any): void;
|
|
1296
|
+
on(event: string, handler: (data: any) => void): void;
|
|
1297
|
+
off(event: string, handler: (data: any) => void): void;
|
|
1298
|
+
}
|
|
1299
|
+
interface ContextData {
|
|
1300
|
+
openEvent?: Event | undefined;
|
|
1301
|
+
floatingContext?: FloatingContext | undefined;
|
|
1302
|
+
[key: string]: any;
|
|
1303
|
+
}
|
|
1304
|
+
type FloatingRootContext = FloatingRootStore;
|
|
1305
|
+
type FloatingContext = Omit<UseFloatingReturn<ReferenceType>, 'refs' | 'elements'> & {
|
|
1306
|
+
open: boolean;
|
|
1307
|
+
onOpenChange(open: boolean, eventDetails: BaseUIChangeEventDetails<string>): void;
|
|
1308
|
+
events: FloatingEvents;
|
|
1309
|
+
dataRef: React$1.RefObject<ContextData>;
|
|
1310
|
+
nodeId: string | undefined;
|
|
1311
|
+
floatingId: string | undefined;
|
|
1312
|
+
refs: ExtendedRefs;
|
|
1313
|
+
elements: ExtendedElements;
|
|
1314
|
+
rootStore: FloatingRootContext;
|
|
1315
|
+
};
|
|
1316
|
+
type ReferenceType = Element | VirtualElement;
|
|
1317
|
+
//#endregion
|
|
1318
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/internals/useAnchorPositioning.d.mts
|
|
1319
|
+
type Side = 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start';
|
|
1320
|
+
type Align = 'start' | 'center' | 'end';
|
|
1321
|
+
type Boundary = 'clipping-ancestors' | Element | Element[] | Rect;
|
|
1322
|
+
type OffsetFunction = (data: {
|
|
1323
|
+
side: Side;
|
|
1324
|
+
align: Align;
|
|
1325
|
+
anchor: {
|
|
1326
|
+
width: number;
|
|
1327
|
+
height: number;
|
|
1328
|
+
};
|
|
1329
|
+
positioner: {
|
|
1330
|
+
width: number;
|
|
1331
|
+
height: number;
|
|
1332
|
+
};
|
|
1333
|
+
}) => number;
|
|
1334
|
+
interface SideFlipMode {
|
|
1335
|
+
/**
|
|
1336
|
+
* How to avoid collisions on the side axis.
|
|
1337
|
+
* - `'flip'`: If there is not enough space, place the popup on the opposite side.
|
|
1338
|
+
* - `'none'`: Keep the preferred side even if it overflows.
|
|
1339
|
+
*/
|
|
1340
|
+
side?: 'flip' | 'none' | undefined;
|
|
1341
|
+
/**
|
|
1342
|
+
* How to avoid collisions on the align axis.
|
|
1343
|
+
* - `'flip'`: If there is not enough space, swap `'start'` and `'end'` alignment.
|
|
1344
|
+
* - `'shift'`: Keep the alignment and shift the popup to fit within the boundary.
|
|
1345
|
+
* - `'none'`: Keep the preferred alignment even if it overflows.
|
|
1346
|
+
*/
|
|
1347
|
+
align?: 'flip' | 'shift' | 'none' | undefined;
|
|
1348
|
+
/**
|
|
1349
|
+
* If both sides on the preferred axis do not fit, determines whether to fallback
|
|
1350
|
+
* to a side on the perpendicular axis and which logical side to prefer.
|
|
1351
|
+
* - `'start'`: Prefer the logical start side on the perpendicular axis.
|
|
1352
|
+
* - `'end'`: Prefer the logical end side on the perpendicular axis.
|
|
1353
|
+
* - `'none'`: Do not fallback to the perpendicular axis.
|
|
1354
|
+
*/
|
|
1355
|
+
fallbackAxisSide?: 'start' | 'end' | 'none' | undefined;
|
|
1356
|
+
}
|
|
1357
|
+
interface SideShiftMode {
|
|
1358
|
+
/**
|
|
1359
|
+
* How to avoid collisions on the side axis.
|
|
1360
|
+
* - `'shift'`: Keep the preferred side and shift the popup to fit within the boundary.
|
|
1361
|
+
* - `'none'`: Keep the preferred side even if it overflows.
|
|
1362
|
+
*/
|
|
1363
|
+
side?: 'shift' | 'none' | undefined;
|
|
1364
|
+
/**
|
|
1365
|
+
* How to avoid collisions on the align axis.
|
|
1366
|
+
* - `'shift'`: Keep the alignment and shift the popup to fit within the boundary.
|
|
1367
|
+
* - `'none'`: Keep the preferred alignment even if it overflows.
|
|
1368
|
+
*/
|
|
1369
|
+
align?: 'shift' | 'none' | undefined;
|
|
1370
|
+
/**
|
|
1371
|
+
* If both sides on the preferred axis do not fit, determines whether to fallback
|
|
1372
|
+
* to a side on the perpendicular axis and which logical side to prefer.
|
|
1373
|
+
* - `'start'`: Prefer the logical start side on the perpendicular axis.
|
|
1374
|
+
* - `'end'`: Prefer the logical end side on the perpendicular axis.
|
|
1375
|
+
* - `'none'`: Do not fallback to the perpendicular axis.
|
|
1376
|
+
*/
|
|
1377
|
+
fallbackAxisSide?: 'start' | 'end' | 'none' | undefined;
|
|
1378
|
+
}
|
|
1379
|
+
type CollisionAvoidance = SideFlipMode | SideShiftMode;
|
|
1380
|
+
interface UseAnchorPositioningSharedParameters {
|
|
1381
|
+
/**
|
|
1382
|
+
* An element to position the popup against.
|
|
1383
|
+
* By default, the popup will be positioned against the trigger.
|
|
1384
|
+
*/
|
|
1385
|
+
anchor?: Element | null | VirtualElement | React$1.RefObject<Element | null> | (() => Element | VirtualElement | null) | undefined;
|
|
1386
|
+
/**
|
|
1387
|
+
* Determines which CSS `position` property to use.
|
|
1388
|
+
* @default 'absolute'
|
|
1389
|
+
*/
|
|
1390
|
+
positionMethod?: 'absolute' | 'fixed' | undefined;
|
|
1391
|
+
/**
|
|
1392
|
+
* Which side of the anchor element to align the popup against.
|
|
1393
|
+
* May automatically change to avoid collisions.
|
|
1394
|
+
* @default 'bottom'
|
|
1395
|
+
*/
|
|
1396
|
+
side?: Side | undefined;
|
|
1397
|
+
/**
|
|
1398
|
+
* Distance between the anchor and the popup in pixels.
|
|
1399
|
+
* Also accepts a function that returns the distance to read the dimensions of the anchor
|
|
1400
|
+
* and positioner elements, along with its side and alignment.
|
|
1401
|
+
*
|
|
1402
|
+
* The function takes a `data` object parameter with the following properties:
|
|
1403
|
+
* - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
|
|
1404
|
+
* - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
|
|
1405
|
+
* - `data.side`: which side of the anchor element the positioner is aligned against.
|
|
1406
|
+
* - `data.align`: how the positioner is aligned relative to the specified side.
|
|
1407
|
+
*
|
|
1408
|
+
* @example
|
|
1409
|
+
* ```jsx
|
|
1410
|
+
* <Positioner
|
|
1411
|
+
* sideOffset={({ side, align, anchor, positioner }) => {
|
|
1412
|
+
* return side === 'top' || side === 'bottom'
|
|
1413
|
+
* ? anchor.height
|
|
1414
|
+
* : anchor.width;
|
|
1415
|
+
* }}
|
|
1416
|
+
* />
|
|
1417
|
+
* ```
|
|
1418
|
+
*
|
|
1419
|
+
* @default 0
|
|
1420
|
+
*/
|
|
1421
|
+
sideOffset?: number | OffsetFunction | undefined;
|
|
1422
|
+
/**
|
|
1423
|
+
* How to align the popup relative to the specified side.
|
|
1424
|
+
* @default 'center'
|
|
1425
|
+
*/
|
|
1426
|
+
align?: Align | undefined;
|
|
1427
|
+
/**
|
|
1428
|
+
* Additional offset along the alignment axis in pixels.
|
|
1429
|
+
* Also accepts a function that returns the offset to read the dimensions of the anchor
|
|
1430
|
+
* and positioner elements, along with its side and alignment.
|
|
1431
|
+
*
|
|
1432
|
+
* The function takes a `data` object parameter with the following properties:
|
|
1433
|
+
* - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
|
|
1434
|
+
* - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
|
|
1435
|
+
* - `data.side`: which side of the anchor element the positioner is aligned against.
|
|
1436
|
+
* - `data.align`: how the positioner is aligned relative to the specified side.
|
|
1437
|
+
*
|
|
1438
|
+
* @example
|
|
1439
|
+
* ```jsx
|
|
1440
|
+
* <Positioner
|
|
1441
|
+
* alignOffset={({ side, align, anchor, positioner }) => {
|
|
1442
|
+
* return side === 'top' || side === 'bottom'
|
|
1443
|
+
* ? anchor.width
|
|
1444
|
+
* : anchor.height;
|
|
1445
|
+
* }}
|
|
1446
|
+
* />
|
|
1447
|
+
* ```
|
|
1448
|
+
*
|
|
1449
|
+
* @default 0
|
|
1450
|
+
*/
|
|
1451
|
+
alignOffset?: number | OffsetFunction | undefined;
|
|
1452
|
+
/**
|
|
1453
|
+
* An element or a rectangle that delimits the area that the popup is confined to.
|
|
1454
|
+
* @default 'clipping-ancestors'
|
|
1455
|
+
*/
|
|
1456
|
+
collisionBoundary?: Boundary | undefined;
|
|
1457
|
+
/**
|
|
1458
|
+
* Additional space to maintain from the edge of the collision boundary.
|
|
1459
|
+
* @default 5
|
|
1460
|
+
*/
|
|
1461
|
+
collisionPadding?: Padding | undefined;
|
|
1462
|
+
/**
|
|
1463
|
+
* Whether to maintain the popup in the viewport after
|
|
1464
|
+
* the anchor element was scrolled out of view.
|
|
1465
|
+
* @default false
|
|
1466
|
+
*/
|
|
1467
|
+
sticky?: boolean | undefined;
|
|
1468
|
+
/**
|
|
1469
|
+
* Minimum distance to maintain between the arrow and the edges of the popup.
|
|
1470
|
+
*
|
|
1471
|
+
* Use it to prevent the arrow element from hanging out of the rounded corners of a popup.
|
|
1472
|
+
* @default 5
|
|
1473
|
+
*/
|
|
1474
|
+
arrowPadding?: number | undefined;
|
|
1475
|
+
/**
|
|
1476
|
+
* Whether to disable the popup from tracking any layout shift of its positioning anchor.
|
|
1477
|
+
* @default false
|
|
1478
|
+
*/
|
|
1479
|
+
disableAnchorTracking?: boolean | undefined;
|
|
1480
|
+
/**
|
|
1481
|
+
* Determines how to handle collisions when positioning the popup.
|
|
1482
|
+
*
|
|
1483
|
+
* `side` controls overflow on the preferred placement axis (`top`/`bottom` or `left`/`right`):
|
|
1484
|
+
* - `'flip'`: keep the requested side when it fits; otherwise try the opposite side
|
|
1485
|
+
* (`top` and `bottom`, or `left` and `right`).
|
|
1486
|
+
* - `'shift'`: never change side; keep the requested side and move the popup within
|
|
1487
|
+
* the clipping boundary so it stays visible.
|
|
1488
|
+
* - `'none'`: do not correct side-axis overflow.
|
|
1489
|
+
*
|
|
1490
|
+
* `align` controls overflow on the alignment axis (`start`/`center`/`end`):
|
|
1491
|
+
* - `'flip'`: keep side, but swap `start` and `end` when the requested alignment overflows.
|
|
1492
|
+
* - `'shift'`: keep side and requested alignment, then nudge the popup along the
|
|
1493
|
+
* alignment axis to fit.
|
|
1494
|
+
* - `'none'`: do not correct alignment-axis overflow.
|
|
1495
|
+
*
|
|
1496
|
+
* `fallbackAxisSide` controls fallback behavior on the perpendicular axis when the
|
|
1497
|
+
* preferred axis cannot fit:
|
|
1498
|
+
* - `'start'`: allow perpendicular fallback and try the logical start side first
|
|
1499
|
+
* (`top` before `bottom`, or `left` before `right` in LTR).
|
|
1500
|
+
* - `'end'`: allow perpendicular fallback and try the logical end side first
|
|
1501
|
+
* (`bottom` before `top`, or `right` before `left` in LTR).
|
|
1502
|
+
* - `'none'`: do not fallback to the perpendicular axis.
|
|
1503
|
+
*
|
|
1504
|
+
* When `side` is `'shift'`, explicitly setting `align` only supports `'shift'` or `'none'`.
|
|
1505
|
+
* If `align` is omitted, it defaults to `'flip'`.
|
|
1506
|
+
*
|
|
1507
|
+
* @example
|
|
1508
|
+
* ```jsx
|
|
1509
|
+
* <Positioner
|
|
1510
|
+
* collisionAvoidance={{
|
|
1511
|
+
* side: 'shift',
|
|
1512
|
+
* align: 'shift',
|
|
1513
|
+
* fallbackAxisSide: 'none',
|
|
1514
|
+
* }}
|
|
1515
|
+
* />
|
|
1516
|
+
* ```
|
|
1517
|
+
*
|
|
1518
|
+
*/
|
|
1519
|
+
collisionAvoidance?: CollisionAvoidance | undefined;
|
|
1520
|
+
}
|
|
1521
|
+
//#endregion
|
|
1522
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/utils/adaptiveOriginConstants.d.mts
|
|
1523
|
+
type AdaptiveOriginMiddleware = {
|
|
1524
|
+
name: string;
|
|
1525
|
+
fn: (...args: any[]) => any;
|
|
1526
|
+
};
|
|
1527
|
+
//#endregion
|
|
1528
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/separator/Separator.d.mts
|
|
1529
|
+
/**
|
|
1530
|
+
* A separator element accessible to screen readers.
|
|
1531
|
+
* Renders a `<div>` element.
|
|
1532
|
+
*
|
|
1533
|
+
* Documentation: [Base UI Separator](https://base-ui.com/react/components/separator)
|
|
1534
|
+
*/
|
|
1535
|
+
declare const Separator$1: React$1.ForwardRefExoticComponent<Omit<SeparatorProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
|
|
1536
|
+
interface SeparatorProps extends BaseUIComponentProps<'div', SeparatorState> {
|
|
1537
|
+
/**
|
|
1538
|
+
* The orientation of the separator.
|
|
1539
|
+
* @default 'horizontal'
|
|
1540
|
+
*/
|
|
1541
|
+
orientation?: Orientation | undefined;
|
|
1542
|
+
}
|
|
1543
|
+
interface SeparatorState {
|
|
1544
|
+
/**
|
|
1545
|
+
* The orientation of the separator.
|
|
1546
|
+
*/
|
|
1547
|
+
orientation: Orientation;
|
|
1548
|
+
}
|
|
1549
|
+
declare namespace Separator$1 {
|
|
1550
|
+
type Props = SeparatorProps;
|
|
1551
|
+
type State = SeparatorState;
|
|
1552
|
+
}
|
|
1553
|
+
//#endregion
|
|
1554
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/toggle/Toggle.d.mts
|
|
1555
|
+
/**
|
|
1556
|
+
* A two-state button that can be on or off.
|
|
1557
|
+
* Renders a `<button>` element.
|
|
1558
|
+
*
|
|
1559
|
+
* Documentation: [Base UI Toggle](https://base-ui.com/react/components/toggle)
|
|
1560
|
+
*/
|
|
1561
|
+
declare const Toggle$1: {
|
|
1562
|
+
<Value extends string>(props: Toggle$1.Props<Value> & React$1.RefAttributes<HTMLButtonElement>): React$1.JSX.Element;
|
|
1563
|
+
};
|
|
1564
|
+
interface ToggleState {
|
|
1565
|
+
/**
|
|
1566
|
+
* Whether the toggle is currently pressed.
|
|
1567
|
+
*/
|
|
1568
|
+
pressed: boolean;
|
|
1569
|
+
/**
|
|
1570
|
+
* Whether the toggle should ignore user interaction.
|
|
1571
|
+
*/
|
|
1572
|
+
disabled: boolean;
|
|
1573
|
+
}
|
|
1574
|
+
interface ToggleProps<Value extends string> extends NativeButtonProps, BaseUIComponentProps<'button', ToggleState> {
|
|
1575
|
+
/**
|
|
1576
|
+
* Whether the toggle button is currently pressed.
|
|
1577
|
+
* This is the controlled counterpart of `defaultPressed`.
|
|
1578
|
+
*/
|
|
1579
|
+
pressed?: boolean | undefined;
|
|
1580
|
+
/**
|
|
1581
|
+
* Whether the toggle button is currently pressed.
|
|
1582
|
+
* This is the uncontrolled counterpart of `pressed`.
|
|
1583
|
+
* @default false
|
|
1584
|
+
*/
|
|
1585
|
+
defaultPressed?: boolean | undefined;
|
|
1586
|
+
/**
|
|
1587
|
+
* Whether the component should ignore user interaction.
|
|
1588
|
+
* @default false
|
|
1589
|
+
*/
|
|
1590
|
+
disabled?: boolean | undefined;
|
|
1591
|
+
/**
|
|
1592
|
+
* Callback fired when the pressed state is changed.
|
|
1593
|
+
*/
|
|
1594
|
+
onPressedChange?: ((pressed: boolean, eventDetails: Toggle$1.ChangeEventDetails) => void) | undefined;
|
|
1595
|
+
/**
|
|
1596
|
+
* A unique string that identifies the toggle when used
|
|
1597
|
+
* inside a toggle group.
|
|
1598
|
+
*/
|
|
1599
|
+
value?: Value | undefined;
|
|
1600
|
+
}
|
|
1601
|
+
type ToggleChangeEventReason = typeof none;
|
|
1602
|
+
type ToggleChangeEventDetails = BaseUIChangeEventDetails<Toggle$1.ChangeEventReason>;
|
|
1603
|
+
declare namespace Toggle$1 {
|
|
1604
|
+
type State = ToggleState;
|
|
1605
|
+
type Props<TValue extends string = string> = ToggleProps<TValue>;
|
|
1606
|
+
type ChangeEventReason = ToggleChangeEventReason;
|
|
1607
|
+
type ChangeEventDetails = ToggleChangeEventDetails;
|
|
1608
|
+
}
|
|
1609
|
+
//#endregion
|
|
1610
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/toggle-group/ToggleGroup.d.mts
|
|
1611
|
+
/**
|
|
1612
|
+
* Provides a shared state to a series of toggle buttons.
|
|
1613
|
+
*
|
|
1614
|
+
* Documentation: [Base UI Toggle Group](https://base-ui.com/react/components/toggle-group)
|
|
1615
|
+
*/
|
|
1616
|
+
declare const ToggleGroup$1: {
|
|
1617
|
+
<Value extends string>(props: ToggleGroup$1.Props<Value> & React$1.RefAttributes<HTMLDivElement>): React$1.JSX.Element;
|
|
1618
|
+
};
|
|
1619
|
+
interface ToggleGroupState {
|
|
1620
|
+
/**
|
|
1621
|
+
* Whether the component should ignore user interaction.
|
|
1622
|
+
*/
|
|
1623
|
+
disabled: boolean;
|
|
1624
|
+
/**
|
|
1625
|
+
* When `false` only one item in the group can be pressed. If any item in
|
|
1626
|
+
* the group becomes pressed, the others will become unpressed.
|
|
1627
|
+
* When `true` multiple items can be pressed.
|
|
1628
|
+
* @default false
|
|
1629
|
+
*/
|
|
1630
|
+
multiple: boolean;
|
|
1631
|
+
/**
|
|
1632
|
+
* The orientation of the toggle group.
|
|
1633
|
+
*/
|
|
1634
|
+
orientation: Orientation;
|
|
1635
|
+
}
|
|
1636
|
+
interface ToggleGroupProps<Value extends string> extends BaseUIComponentProps<'div', ToggleGroupState> {
|
|
1637
|
+
/**
|
|
1638
|
+
* The pressed state of the toggle group represented by an array of
|
|
1639
|
+
* the values of all pressed toggle buttons.
|
|
1640
|
+
* This is the controlled counterpart of `defaultValue`.
|
|
1641
|
+
*/
|
|
1642
|
+
value?: readonly Value[] | undefined;
|
|
1643
|
+
/**
|
|
1644
|
+
* The pressed state of the toggle group represented by an array of
|
|
1645
|
+
* the values of all pressed toggle buttons.
|
|
1646
|
+
* This is the uncontrolled counterpart of `value`.
|
|
1647
|
+
*/
|
|
1648
|
+
defaultValue?: readonly Value[] | undefined;
|
|
1649
|
+
/**
|
|
1650
|
+
* Callback fired when the pressed states of the toggle group changes.
|
|
1651
|
+
*/
|
|
1652
|
+
onValueChange?: ((groupValue: Value[], eventDetails: ToggleGroup$1.ChangeEventDetails) => void) | undefined;
|
|
1653
|
+
/**
|
|
1654
|
+
* Whether the toggle group should ignore user interaction.
|
|
1655
|
+
* @default false
|
|
1656
|
+
*/
|
|
1657
|
+
disabled?: boolean | undefined;
|
|
1658
|
+
/**
|
|
1659
|
+
* @default 'horizontal'
|
|
1660
|
+
*/
|
|
1661
|
+
orientation?: Orientation | undefined;
|
|
1662
|
+
/**
|
|
1663
|
+
* Whether to loop keyboard focus back to the first item
|
|
1664
|
+
* when the end of the list is reached while using the arrow keys.
|
|
1665
|
+
* @default true
|
|
1666
|
+
*/
|
|
1667
|
+
loopFocus?: boolean | undefined;
|
|
1668
|
+
/**
|
|
1669
|
+
* When `false` only one item in the group can be pressed. If any item in
|
|
1670
|
+
* the group becomes pressed, the others will become unpressed.
|
|
1671
|
+
* When `true` multiple items can be pressed.
|
|
1672
|
+
* @default false
|
|
1673
|
+
*/
|
|
1674
|
+
multiple?: boolean | undefined;
|
|
1675
|
+
}
|
|
1676
|
+
type ToggleGroupChangeEventReason = typeof none;
|
|
1677
|
+
type ToggleGroupChangeEventDetails = BaseUIChangeEventDetails<ToggleGroup$1.ChangeEventReason>;
|
|
1678
|
+
declare namespace ToggleGroup$1 {
|
|
1679
|
+
type State = ToggleGroupState;
|
|
1680
|
+
type Props<Value extends string = string> = ToggleGroupProps<Value>;
|
|
1681
|
+
type ChangeEventReason = ToggleGroupChangeEventReason;
|
|
1682
|
+
type ChangeEventDetails = ToggleGroupChangeEventDetails;
|
|
1683
|
+
}
|
|
1684
|
+
//#endregion
|
|
1685
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/tooltip/store/TooltipStore.d.mts
|
|
1686
|
+
type State$1<Payload> = PopupStoreState<Payload> & {
|
|
1687
|
+
disabled: boolean;
|
|
1688
|
+
instantType: 'delay' | 'dismiss' | 'focus' | undefined;
|
|
1689
|
+
isInstantPhase: boolean;
|
|
1690
|
+
trackCursorAxis: 'none' | 'x' | 'y' | 'both';
|
|
1691
|
+
disableHoverablePopup: boolean;
|
|
1692
|
+
openChangeReason: TooltipRoot.ChangeEventReason | null;
|
|
1693
|
+
closeOnClick: boolean;
|
|
1694
|
+
closeDelay: number;
|
|
1695
|
+
adaptiveOrigin: AdaptiveOriginMiddleware | undefined;
|
|
1696
|
+
};
|
|
1697
|
+
type Context$1 = PopupStoreContext<TooltipRoot.ChangeEventDetails> & {
|
|
1698
|
+
readonly popupRef: React$1.RefObject<HTMLElement | null>;
|
|
1699
|
+
};
|
|
1700
|
+
declare const selectors$1: {
|
|
1701
|
+
open: (state: {
|
|
1702
|
+
open: boolean;
|
|
1703
|
+
readonly openProp: boolean | undefined;
|
|
1704
|
+
mounted: boolean;
|
|
1705
|
+
transitionStatus: TransitionStatus;
|
|
1706
|
+
floatingRootContext: FloatingRootContext;
|
|
1707
|
+
floatingId: string | undefined;
|
|
1708
|
+
triggerCount: number;
|
|
1709
|
+
preventUnmountingOnClose: boolean;
|
|
1710
|
+
payload: unknown;
|
|
1711
|
+
activeTriggerId: string | null;
|
|
1712
|
+
activeTriggerElement: Element | null;
|
|
1713
|
+
openedWithoutTrigger: boolean;
|
|
1714
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1715
|
+
popupElement: HTMLElement | null;
|
|
1716
|
+
positionerElement: HTMLElement | null;
|
|
1717
|
+
activeTriggerProps: HTMLProps;
|
|
1718
|
+
inactiveTriggerProps: HTMLProps;
|
|
1719
|
+
popupProps: HTMLProps;
|
|
1720
|
+
}) => boolean;
|
|
1721
|
+
mounted: (state: {
|
|
1722
|
+
open: boolean;
|
|
1723
|
+
readonly openProp: boolean | undefined;
|
|
1724
|
+
mounted: boolean;
|
|
1725
|
+
transitionStatus: TransitionStatus;
|
|
1726
|
+
floatingRootContext: FloatingRootContext;
|
|
1727
|
+
floatingId: string | undefined;
|
|
1728
|
+
triggerCount: number;
|
|
1729
|
+
preventUnmountingOnClose: boolean;
|
|
1730
|
+
payload: unknown;
|
|
1731
|
+
activeTriggerId: string | null;
|
|
1732
|
+
activeTriggerElement: Element | null;
|
|
1733
|
+
openedWithoutTrigger: boolean;
|
|
1734
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1735
|
+
popupElement: HTMLElement | null;
|
|
1736
|
+
positionerElement: HTMLElement | null;
|
|
1737
|
+
activeTriggerProps: HTMLProps;
|
|
1738
|
+
inactiveTriggerProps: HTMLProps;
|
|
1739
|
+
popupProps: HTMLProps;
|
|
1740
|
+
}) => boolean;
|
|
1741
|
+
transitionStatus: (state: {
|
|
1742
|
+
open: boolean;
|
|
1743
|
+
readonly openProp: boolean | undefined;
|
|
1744
|
+
mounted: boolean;
|
|
1745
|
+
transitionStatus: TransitionStatus;
|
|
1746
|
+
floatingRootContext: FloatingRootContext;
|
|
1747
|
+
floatingId: string | undefined;
|
|
1748
|
+
triggerCount: number;
|
|
1749
|
+
preventUnmountingOnClose: boolean;
|
|
1750
|
+
payload: unknown;
|
|
1751
|
+
activeTriggerId: string | null;
|
|
1752
|
+
activeTriggerElement: Element | null;
|
|
1753
|
+
openedWithoutTrigger: boolean;
|
|
1754
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1755
|
+
popupElement: HTMLElement | null;
|
|
1756
|
+
positionerElement: HTMLElement | null;
|
|
1757
|
+
activeTriggerProps: HTMLProps;
|
|
1758
|
+
inactiveTriggerProps: HTMLProps;
|
|
1759
|
+
popupProps: HTMLProps;
|
|
1760
|
+
}) => TransitionStatus;
|
|
1761
|
+
floatingRootContext: (state: {
|
|
1762
|
+
open: boolean;
|
|
1763
|
+
readonly openProp: boolean | undefined;
|
|
1764
|
+
mounted: boolean;
|
|
1765
|
+
transitionStatus: TransitionStatus;
|
|
1766
|
+
floatingRootContext: FloatingRootContext;
|
|
1767
|
+
floatingId: string | undefined;
|
|
1768
|
+
triggerCount: number;
|
|
1769
|
+
preventUnmountingOnClose: boolean;
|
|
1770
|
+
payload: unknown;
|
|
1771
|
+
activeTriggerId: string | null;
|
|
1772
|
+
activeTriggerElement: Element | null;
|
|
1773
|
+
openedWithoutTrigger: boolean;
|
|
1774
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1775
|
+
popupElement: HTMLElement | null;
|
|
1776
|
+
positionerElement: HTMLElement | null;
|
|
1777
|
+
activeTriggerProps: HTMLProps;
|
|
1778
|
+
inactiveTriggerProps: HTMLProps;
|
|
1779
|
+
popupProps: HTMLProps;
|
|
1780
|
+
}) => FloatingRootStore;
|
|
1781
|
+
triggerCount: (state: {
|
|
1782
|
+
open: boolean;
|
|
1783
|
+
readonly openProp: boolean | undefined;
|
|
1784
|
+
mounted: boolean;
|
|
1785
|
+
transitionStatus: TransitionStatus;
|
|
1786
|
+
floatingRootContext: FloatingRootContext;
|
|
1787
|
+
floatingId: string | undefined;
|
|
1788
|
+
triggerCount: number;
|
|
1789
|
+
preventUnmountingOnClose: boolean;
|
|
1790
|
+
payload: unknown;
|
|
1791
|
+
activeTriggerId: string | null;
|
|
1792
|
+
activeTriggerElement: Element | null;
|
|
1793
|
+
openedWithoutTrigger: boolean;
|
|
1794
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1795
|
+
popupElement: HTMLElement | null;
|
|
1796
|
+
positionerElement: HTMLElement | null;
|
|
1797
|
+
activeTriggerProps: HTMLProps;
|
|
1798
|
+
inactiveTriggerProps: HTMLProps;
|
|
1799
|
+
popupProps: HTMLProps;
|
|
1800
|
+
}) => number;
|
|
1801
|
+
preventUnmountingOnClose: (state: {
|
|
1802
|
+
open: boolean;
|
|
1803
|
+
readonly openProp: boolean | undefined;
|
|
1804
|
+
mounted: boolean;
|
|
1805
|
+
transitionStatus: TransitionStatus;
|
|
1806
|
+
floatingRootContext: FloatingRootContext;
|
|
1807
|
+
floatingId: string | undefined;
|
|
1808
|
+
triggerCount: number;
|
|
1809
|
+
preventUnmountingOnClose: boolean;
|
|
1810
|
+
payload: unknown;
|
|
1811
|
+
activeTriggerId: string | null;
|
|
1812
|
+
activeTriggerElement: Element | null;
|
|
1813
|
+
openedWithoutTrigger: boolean;
|
|
1814
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1815
|
+
popupElement: HTMLElement | null;
|
|
1816
|
+
positionerElement: HTMLElement | null;
|
|
1817
|
+
activeTriggerProps: HTMLProps;
|
|
1818
|
+
inactiveTriggerProps: HTMLProps;
|
|
1819
|
+
popupProps: HTMLProps;
|
|
1820
|
+
}) => boolean;
|
|
1821
|
+
payload: (state: {
|
|
1822
|
+
open: boolean;
|
|
1823
|
+
readonly openProp: boolean | undefined;
|
|
1824
|
+
mounted: boolean;
|
|
1825
|
+
transitionStatus: TransitionStatus;
|
|
1826
|
+
floatingRootContext: FloatingRootContext;
|
|
1827
|
+
floatingId: string | undefined;
|
|
1828
|
+
triggerCount: number;
|
|
1829
|
+
preventUnmountingOnClose: boolean;
|
|
1830
|
+
payload: unknown;
|
|
1831
|
+
activeTriggerId: string | null;
|
|
1832
|
+
activeTriggerElement: Element | null;
|
|
1833
|
+
openedWithoutTrigger: boolean;
|
|
1834
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1835
|
+
popupElement: HTMLElement | null;
|
|
1836
|
+
positionerElement: HTMLElement | null;
|
|
1837
|
+
activeTriggerProps: HTMLProps;
|
|
1838
|
+
inactiveTriggerProps: HTMLProps;
|
|
1839
|
+
popupProps: HTMLProps;
|
|
1840
|
+
}) => unknown;
|
|
1841
|
+
activeTriggerId: (state: {
|
|
1842
|
+
open: boolean;
|
|
1843
|
+
readonly openProp: boolean | undefined;
|
|
1844
|
+
mounted: boolean;
|
|
1845
|
+
transitionStatus: TransitionStatus;
|
|
1846
|
+
floatingRootContext: FloatingRootContext;
|
|
1847
|
+
floatingId: string | undefined;
|
|
1848
|
+
triggerCount: number;
|
|
1849
|
+
preventUnmountingOnClose: boolean;
|
|
1850
|
+
payload: unknown;
|
|
1851
|
+
activeTriggerId: string | null;
|
|
1852
|
+
activeTriggerElement: Element | null;
|
|
1853
|
+
openedWithoutTrigger: boolean;
|
|
1854
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1855
|
+
popupElement: HTMLElement | null;
|
|
1856
|
+
positionerElement: HTMLElement | null;
|
|
1857
|
+
activeTriggerProps: HTMLProps;
|
|
1858
|
+
inactiveTriggerProps: HTMLProps;
|
|
1859
|
+
popupProps: HTMLProps;
|
|
1860
|
+
}) => string | null;
|
|
1861
|
+
activeTriggerElement: (state: {
|
|
1862
|
+
open: boolean;
|
|
1863
|
+
readonly openProp: boolean | undefined;
|
|
1864
|
+
mounted: boolean;
|
|
1865
|
+
transitionStatus: TransitionStatus;
|
|
1866
|
+
floatingRootContext: FloatingRootContext;
|
|
1867
|
+
floatingId: string | undefined;
|
|
1868
|
+
triggerCount: number;
|
|
1869
|
+
preventUnmountingOnClose: boolean;
|
|
1870
|
+
payload: unknown;
|
|
1871
|
+
activeTriggerId: string | null;
|
|
1872
|
+
activeTriggerElement: Element | null;
|
|
1873
|
+
openedWithoutTrigger: boolean;
|
|
1874
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1875
|
+
popupElement: HTMLElement | null;
|
|
1876
|
+
positionerElement: HTMLElement | null;
|
|
1877
|
+
activeTriggerProps: HTMLProps;
|
|
1878
|
+
inactiveTriggerProps: HTMLProps;
|
|
1879
|
+
popupProps: HTMLProps;
|
|
1880
|
+
}) => Element | null;
|
|
1881
|
+
popupId: (state: {
|
|
1882
|
+
open: boolean;
|
|
1883
|
+
readonly openProp: boolean | undefined;
|
|
1884
|
+
mounted: boolean;
|
|
1885
|
+
transitionStatus: TransitionStatus;
|
|
1886
|
+
floatingRootContext: FloatingRootContext;
|
|
1887
|
+
floatingId: string | undefined;
|
|
1888
|
+
triggerCount: number;
|
|
1889
|
+
preventUnmountingOnClose: boolean;
|
|
1890
|
+
payload: unknown;
|
|
1891
|
+
activeTriggerId: string | null;
|
|
1892
|
+
activeTriggerElement: Element | null;
|
|
1893
|
+
openedWithoutTrigger: boolean;
|
|
1894
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1895
|
+
popupElement: HTMLElement | null;
|
|
1896
|
+
positionerElement: HTMLElement | null;
|
|
1897
|
+
activeTriggerProps: HTMLProps;
|
|
1898
|
+
inactiveTriggerProps: HTMLProps;
|
|
1899
|
+
popupProps: HTMLProps;
|
|
1900
|
+
}) => string | undefined;
|
|
1901
|
+
isTriggerActive: (state: {
|
|
1902
|
+
open: boolean;
|
|
1903
|
+
readonly openProp: boolean | undefined;
|
|
1904
|
+
mounted: boolean;
|
|
1905
|
+
transitionStatus: TransitionStatus;
|
|
1906
|
+
floatingRootContext: FloatingRootContext;
|
|
1907
|
+
floatingId: string | undefined;
|
|
1908
|
+
triggerCount: number;
|
|
1909
|
+
preventUnmountingOnClose: boolean;
|
|
1910
|
+
payload: unknown;
|
|
1911
|
+
activeTriggerId: string | null;
|
|
1912
|
+
activeTriggerElement: Element | null;
|
|
1913
|
+
openedWithoutTrigger: boolean;
|
|
1914
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1915
|
+
popupElement: HTMLElement | null;
|
|
1916
|
+
positionerElement: HTMLElement | null;
|
|
1917
|
+
activeTriggerProps: HTMLProps;
|
|
1918
|
+
inactiveTriggerProps: HTMLProps;
|
|
1919
|
+
popupProps: HTMLProps;
|
|
1920
|
+
}, triggerId: string | undefined) => boolean;
|
|
1921
|
+
isOpenedByTrigger: (state: {
|
|
1922
|
+
open: boolean;
|
|
1923
|
+
readonly openProp: boolean | undefined;
|
|
1924
|
+
mounted: boolean;
|
|
1925
|
+
transitionStatus: TransitionStatus;
|
|
1926
|
+
floatingRootContext: FloatingRootContext;
|
|
1927
|
+
floatingId: string | undefined;
|
|
1928
|
+
triggerCount: number;
|
|
1929
|
+
preventUnmountingOnClose: boolean;
|
|
1930
|
+
payload: unknown;
|
|
1931
|
+
activeTriggerId: string | null;
|
|
1932
|
+
activeTriggerElement: Element | null;
|
|
1933
|
+
openedWithoutTrigger: boolean;
|
|
1934
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1935
|
+
popupElement: HTMLElement | null;
|
|
1936
|
+
positionerElement: HTMLElement | null;
|
|
1937
|
+
activeTriggerProps: HTMLProps;
|
|
1938
|
+
inactiveTriggerProps: HTMLProps;
|
|
1939
|
+
popupProps: HTMLProps;
|
|
1940
|
+
}, triggerId: string | undefined) => boolean;
|
|
1941
|
+
isMountedByTrigger: (state: {
|
|
1942
|
+
open: boolean;
|
|
1943
|
+
readonly openProp: boolean | undefined;
|
|
1944
|
+
mounted: boolean;
|
|
1945
|
+
transitionStatus: TransitionStatus;
|
|
1946
|
+
floatingRootContext: FloatingRootContext;
|
|
1947
|
+
floatingId: string | undefined;
|
|
1948
|
+
triggerCount: number;
|
|
1949
|
+
preventUnmountingOnClose: boolean;
|
|
1950
|
+
payload: unknown;
|
|
1951
|
+
activeTriggerId: string | null;
|
|
1952
|
+
activeTriggerElement: Element | null;
|
|
1953
|
+
openedWithoutTrigger: boolean;
|
|
1954
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1955
|
+
popupElement: HTMLElement | null;
|
|
1956
|
+
positionerElement: HTMLElement | null;
|
|
1957
|
+
activeTriggerProps: HTMLProps;
|
|
1958
|
+
inactiveTriggerProps: HTMLProps;
|
|
1959
|
+
popupProps: HTMLProps;
|
|
1960
|
+
}, triggerId: string | undefined) => boolean;
|
|
1961
|
+
triggerProps: (state: {
|
|
1962
|
+
open: boolean;
|
|
1963
|
+
readonly openProp: boolean | undefined;
|
|
1964
|
+
mounted: boolean;
|
|
1965
|
+
transitionStatus: TransitionStatus;
|
|
1966
|
+
floatingRootContext: FloatingRootContext;
|
|
1967
|
+
floatingId: string | undefined;
|
|
1968
|
+
triggerCount: number;
|
|
1969
|
+
preventUnmountingOnClose: boolean;
|
|
1970
|
+
payload: unknown;
|
|
1971
|
+
activeTriggerId: string | null;
|
|
1972
|
+
activeTriggerElement: Element | null;
|
|
1973
|
+
openedWithoutTrigger: boolean;
|
|
1974
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1975
|
+
popupElement: HTMLElement | null;
|
|
1976
|
+
positionerElement: HTMLElement | null;
|
|
1977
|
+
activeTriggerProps: HTMLProps;
|
|
1978
|
+
inactiveTriggerProps: HTMLProps;
|
|
1979
|
+
popupProps: HTMLProps;
|
|
1980
|
+
}, isActive: boolean) => HTMLProps;
|
|
1981
|
+
triggerPopupId: (state: {
|
|
1982
|
+
open: boolean;
|
|
1983
|
+
readonly openProp: boolean | undefined;
|
|
1984
|
+
mounted: boolean;
|
|
1985
|
+
transitionStatus: TransitionStatus;
|
|
1986
|
+
floatingRootContext: FloatingRootContext;
|
|
1987
|
+
floatingId: string | undefined;
|
|
1988
|
+
triggerCount: number;
|
|
1989
|
+
preventUnmountingOnClose: boolean;
|
|
1990
|
+
payload: unknown;
|
|
1991
|
+
activeTriggerId: string | null;
|
|
1992
|
+
activeTriggerElement: Element | null;
|
|
1993
|
+
openedWithoutTrigger: boolean;
|
|
1994
|
+
readonly triggerIdProp: string | null | undefined;
|
|
1995
|
+
popupElement: HTMLElement | null;
|
|
1996
|
+
positionerElement: HTMLElement | null;
|
|
1997
|
+
activeTriggerProps: HTMLProps;
|
|
1998
|
+
inactiveTriggerProps: HTMLProps;
|
|
1999
|
+
popupProps: HTMLProps;
|
|
2000
|
+
}, triggerId: string | undefined) => string | undefined;
|
|
2001
|
+
popupProps: (state: {
|
|
2002
|
+
open: boolean;
|
|
2003
|
+
readonly openProp: boolean | undefined;
|
|
2004
|
+
mounted: boolean;
|
|
2005
|
+
transitionStatus: TransitionStatus;
|
|
2006
|
+
floatingRootContext: FloatingRootContext;
|
|
2007
|
+
floatingId: string | undefined;
|
|
2008
|
+
triggerCount: number;
|
|
2009
|
+
preventUnmountingOnClose: boolean;
|
|
2010
|
+
payload: unknown;
|
|
2011
|
+
activeTriggerId: string | null;
|
|
2012
|
+
activeTriggerElement: Element | null;
|
|
2013
|
+
openedWithoutTrigger: boolean;
|
|
2014
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2015
|
+
popupElement: HTMLElement | null;
|
|
2016
|
+
positionerElement: HTMLElement | null;
|
|
2017
|
+
activeTriggerProps: HTMLProps;
|
|
2018
|
+
inactiveTriggerProps: HTMLProps;
|
|
2019
|
+
popupProps: HTMLProps;
|
|
2020
|
+
}) => HTMLProps;
|
|
2021
|
+
popupElement: (state: {
|
|
2022
|
+
open: boolean;
|
|
2023
|
+
readonly openProp: boolean | undefined;
|
|
2024
|
+
mounted: boolean;
|
|
2025
|
+
transitionStatus: TransitionStatus;
|
|
2026
|
+
floatingRootContext: FloatingRootContext;
|
|
2027
|
+
floatingId: string | undefined;
|
|
2028
|
+
triggerCount: number;
|
|
2029
|
+
preventUnmountingOnClose: boolean;
|
|
2030
|
+
payload: unknown;
|
|
2031
|
+
activeTriggerId: string | null;
|
|
2032
|
+
activeTriggerElement: Element | null;
|
|
2033
|
+
openedWithoutTrigger: boolean;
|
|
2034
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2035
|
+
popupElement: HTMLElement | null;
|
|
2036
|
+
positionerElement: HTMLElement | null;
|
|
2037
|
+
activeTriggerProps: HTMLProps;
|
|
2038
|
+
inactiveTriggerProps: HTMLProps;
|
|
2039
|
+
popupProps: HTMLProps;
|
|
2040
|
+
}) => HTMLElement | null;
|
|
2041
|
+
positionerElement: (state: {
|
|
2042
|
+
open: boolean;
|
|
2043
|
+
readonly openProp: boolean | undefined;
|
|
2044
|
+
mounted: boolean;
|
|
2045
|
+
transitionStatus: TransitionStatus;
|
|
2046
|
+
floatingRootContext: FloatingRootContext;
|
|
2047
|
+
floatingId: string | undefined;
|
|
2048
|
+
triggerCount: number;
|
|
2049
|
+
preventUnmountingOnClose: boolean;
|
|
2050
|
+
payload: unknown;
|
|
2051
|
+
activeTriggerId: string | null;
|
|
2052
|
+
activeTriggerElement: Element | null;
|
|
2053
|
+
openedWithoutTrigger: boolean;
|
|
2054
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2055
|
+
popupElement: HTMLElement | null;
|
|
2056
|
+
positionerElement: HTMLElement | null;
|
|
2057
|
+
activeTriggerProps: HTMLProps;
|
|
2058
|
+
inactiveTriggerProps: HTMLProps;
|
|
2059
|
+
popupProps: HTMLProps;
|
|
2060
|
+
}) => HTMLElement | null;
|
|
2061
|
+
disabled: (state: State$1<unknown>) => boolean;
|
|
2062
|
+
instantType: (state: State$1<unknown>) => "delay" | "dismiss" | "focus" | undefined;
|
|
2063
|
+
isInstantPhase: (state: State$1<unknown>) => boolean;
|
|
2064
|
+
trackCursorAxis: (state: State$1<unknown>) => "both" | "none" | "x" | "y";
|
|
2065
|
+
disableHoverablePopup: (state: State$1<unknown>) => boolean;
|
|
2066
|
+
lastOpenChangeReason: (state: State$1<unknown>) => TooltipRootChangeEventReason | null;
|
|
2067
|
+
closeOnClick: (state: State$1<unknown>) => boolean;
|
|
2068
|
+
appliedTriggerProps: (state: State$1<unknown>, apply: boolean) => HTMLProps | undefined;
|
|
2069
|
+
closeDelay: (state: State$1<unknown>) => number;
|
|
2070
|
+
adaptiveOrigin: (state: State$1<unknown>) => AdaptiveOriginMiddleware | undefined;
|
|
2071
|
+
};
|
|
2072
|
+
type Selectors$1 = typeof selectors$1;
|
|
2073
|
+
/**
|
|
2074
|
+
* The store view that detached handle-backed triggers read from. Both the real `TooltipStore` and
|
|
2075
|
+
* the inert fallback store satisfy it, so a trigger can read from whichever store the handle
|
|
2076
|
+
* currently exposes. Narrowed to the members a trigger actually uses — the trigger-data members plus
|
|
2077
|
+
* `setOpen`/`cancelPendingOpen` (called directly by the trigger) and `useSyncedValue` — so the
|
|
2078
|
+
* exposed surface can't bypass the open-change pipeline; on the detached fallback store every one of
|
|
2079
|
+
* these mutations is a no-op.
|
|
2080
|
+
*/
|
|
2081
|
+
type TooltipHandleStore<Payload> = Pick<TooltipStore<Payload>, PopupTriggerStoreKeys | 'setOpen' | 'cancelPendingOpen' | 'useSyncedValue'>;
|
|
2082
|
+
declare class TooltipStore<Payload> extends ReactStore<Readonly<State$1<Payload>>, Context$1, Selectors$1> {
|
|
2083
|
+
constructor(initialState: Partial<State$1<Payload>>, floatingId: string | undefined, nested: boolean);
|
|
2084
|
+
setOpen: (nextOpen: boolean, eventDetails: Omit<TooltipRoot.ChangeEventDetails, 'preventUnmountOnClose'>) => void;
|
|
2085
|
+
cancelPendingOpen(event: MouseEvent | PointerEvent): void;
|
|
2086
|
+
}
|
|
2087
|
+
//#endregion
|
|
2088
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/tooltip/store/TooltipHandle.d.mts
|
|
2089
|
+
/**
|
|
2090
|
+
* Controls a Tooltip imperatively and associates detached `Tooltip.Trigger` components with a
|
|
2091
|
+
* `Tooltip.Root`. Create one with `Tooltip.createHandle()` and pass it to the `handle` prop of the
|
|
2092
|
+
* root and of any triggers rendered outside of it.
|
|
2093
|
+
*
|
|
2094
|
+
* The imperative methods take effect only while a root using this handle is mounted; calls made
|
|
2095
|
+
* before a root attaches (or after it unmounts) are ignored.
|
|
2096
|
+
*/
|
|
2097
|
+
declare class TooltipHandle<Payload> extends BasePopupHandle<TooltipHandleStore<Payload>, TooltipStore<Payload>> {
|
|
2098
|
+
constructor();
|
|
2099
|
+
/**
|
|
2100
|
+
* Opens the tooltip and associates it with the trigger with the given id.
|
|
2101
|
+
*
|
|
2102
|
+
* This method should only be called in an event handler or an effect (not during rendering).
|
|
2103
|
+
*
|
|
2104
|
+
* @param triggerId ID of the trigger to associate with the tooltip. The trigger must be a matching
|
|
2105
|
+
* `Tooltip.Trigger` with this handle passed as a prop.
|
|
2106
|
+
*/
|
|
2107
|
+
open(triggerId: string): void;
|
|
2108
|
+
/**
|
|
2109
|
+
* Closes the tooltip.
|
|
2110
|
+
*
|
|
2111
|
+
* This method should only be called in an event handler or an effect (not during rendering).
|
|
2112
|
+
*/
|
|
2113
|
+
close(): void;
|
|
2114
|
+
/**
|
|
2115
|
+
* Whether the tooltip is currently open. Returns `false` while no root is attached to the handle.
|
|
2116
|
+
*/
|
|
2117
|
+
get isOpen(): boolean;
|
|
2118
|
+
}
|
|
2119
|
+
//#endregion
|
|
2120
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/tooltip/root/TooltipRoot.d.mts
|
|
2121
|
+
/**
|
|
2122
|
+
* Groups all parts of the tooltip.
|
|
2123
|
+
* Doesn't render its own HTML element.
|
|
2124
|
+
*
|
|
2125
|
+
* Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)
|
|
2126
|
+
*/
|
|
2127
|
+
declare const TooltipRoot: <Payload>(props: TooltipRoot.Props<Payload>) => React$1.JSX.Element;
|
|
2128
|
+
interface TooltipRootState {}
|
|
2129
|
+
interface TooltipRootProps<Payload = unknown> {
|
|
2130
|
+
/**
|
|
2131
|
+
* Whether the tooltip is initially open.
|
|
2132
|
+
*
|
|
2133
|
+
* To render a controlled tooltip, use the `open` prop instead.
|
|
2134
|
+
* @default false
|
|
2135
|
+
*/
|
|
2136
|
+
defaultOpen?: boolean | undefined;
|
|
2137
|
+
/**
|
|
2138
|
+
* Whether the tooltip is currently open.
|
|
2139
|
+
*/
|
|
2140
|
+
open?: boolean | undefined;
|
|
2141
|
+
/**
|
|
2142
|
+
* Event handler called when the tooltip is opened or closed.
|
|
2143
|
+
*/
|
|
2144
|
+
onOpenChange?: ((open: boolean, eventDetails: TooltipRoot.ChangeEventDetails) => void) | undefined;
|
|
2145
|
+
/**
|
|
2146
|
+
* Event handler called after any animations complete when the tooltip is opened or closed.
|
|
2147
|
+
*/
|
|
2148
|
+
onOpenChangeComplete?: ((open: boolean) => void) | undefined;
|
|
2149
|
+
/**
|
|
2150
|
+
* Whether the tooltip contents can be hovered without closing the tooltip.
|
|
2151
|
+
* @default false
|
|
2152
|
+
*/
|
|
2153
|
+
disableHoverablePopup?: boolean | undefined;
|
|
2154
|
+
/**
|
|
2155
|
+
* Determines which axis the tooltip should track the cursor on.
|
|
2156
|
+
* @default 'none'
|
|
2157
|
+
*/
|
|
2158
|
+
trackCursorAxis?: 'none' | 'x' | 'y' | 'both' | undefined;
|
|
2159
|
+
/**
|
|
2160
|
+
* A ref to imperative actions.
|
|
2161
|
+
* - `unmount`: Ends the closing phase of the tooltip after an externally controlled closing animation finishes.
|
|
2162
|
+
* Call `preventUnmountOnClose()` in `onOpenChange` first, otherwise the tooltip completes closing on its own.
|
|
2163
|
+
* Whether it leaves the DOM is decided by `keepMounted` on the portal.
|
|
2164
|
+
* - `close`: Closes the tooltip imperatively when called.
|
|
2165
|
+
*/
|
|
2166
|
+
actionsRef?: React$1.RefObject<TooltipRoot.Actions | null> | undefined;
|
|
2167
|
+
/**
|
|
2168
|
+
* Whether the tooltip is disabled.
|
|
2169
|
+
* @default false
|
|
2170
|
+
*/
|
|
2171
|
+
disabled?: boolean | undefined;
|
|
2172
|
+
/**
|
|
2173
|
+
* A handle to associate the tooltip with a trigger.
|
|
2174
|
+
* If specified, allows external triggers to control the tooltip's open state.
|
|
2175
|
+
* Can be created with the Tooltip.createHandle() method.
|
|
2176
|
+
*/
|
|
2177
|
+
handle?: TooltipHandle<Payload> | undefined;
|
|
2178
|
+
/**
|
|
2179
|
+
* The content of the tooltip.
|
|
2180
|
+
* This can be a regular React node or a render function that receives the `payload` of the active trigger.
|
|
2181
|
+
*/
|
|
2182
|
+
children?: React$1.ReactNode | PayloadChildRenderFunction<Payload>;
|
|
2183
|
+
/**
|
|
2184
|
+
* ID of the trigger that the tooltip is associated with.
|
|
2185
|
+
* This is useful in conjunction with the `open` prop to create a controlled tooltip.
|
|
2186
|
+
* There's no need to specify this prop when the tooltip is uncontrolled (that is, when the `open` prop is not set).
|
|
2187
|
+
*/
|
|
2188
|
+
triggerId?: string | null | undefined;
|
|
2189
|
+
/**
|
|
2190
|
+
* ID of the trigger that the tooltip is associated with.
|
|
2191
|
+
* This is useful in conjunction with the `defaultOpen` prop to create an initially open tooltip.
|
|
2192
|
+
*/
|
|
2193
|
+
defaultTriggerId?: string | null | undefined;
|
|
2194
|
+
}
|
|
2195
|
+
interface TooltipRootActions {
|
|
2196
|
+
unmount: () => void;
|
|
2197
|
+
close: () => void;
|
|
2198
|
+
}
|
|
2199
|
+
type TooltipRootChangeEventReason = typeof triggerHover | typeof triggerFocus | typeof triggerPress | typeof outsidePress | typeof escapeKey | typeof disabled | typeof imperativeAction | typeof none;
|
|
2200
|
+
type TooltipRootChangeEventDetails = BaseUIChangeEventDetails<TooltipRoot.ChangeEventReason> & {
|
|
2201
|
+
/** Prevents the popup from unmounting until the `unmount` action is called. */
|
|
2202
|
+
preventUnmountOnClose: () => void;
|
|
2203
|
+
};
|
|
2204
|
+
declare namespace TooltipRoot {
|
|
2205
|
+
type State = TooltipRootState;
|
|
2206
|
+
type Props<Payload = unknown> = TooltipRootProps<Payload>;
|
|
2207
|
+
type Actions = TooltipRootActions;
|
|
2208
|
+
type ChangeEventReason = TooltipRootChangeEventReason;
|
|
2209
|
+
type ChangeEventDetails = TooltipRootChangeEventDetails;
|
|
2210
|
+
}
|
|
2211
|
+
//#endregion
|
|
2212
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/tooltip/trigger/TooltipTrigger.d.mts
|
|
2213
|
+
/**
|
|
2214
|
+
* An element to attach the tooltip to.
|
|
2215
|
+
* Renders a `<button>` element.
|
|
2216
|
+
*
|
|
2217
|
+
* Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)
|
|
2218
|
+
*/
|
|
2219
|
+
declare const TooltipTrigger$1: TooltipTrigger$1;
|
|
2220
|
+
interface TooltipTrigger$1 {
|
|
2221
|
+
<Payload>(componentProps: TooltipTrigger$1.Props<Payload> & React$1.RefAttributes<HTMLElement>): React$1.JSX.Element;
|
|
2222
|
+
}
|
|
2223
|
+
interface TooltipTriggerState {
|
|
2224
|
+
/**
|
|
2225
|
+
* Whether the tooltip is currently open and was opened by this trigger.
|
|
2226
|
+
*/
|
|
2227
|
+
open: boolean;
|
|
2228
|
+
}
|
|
2229
|
+
interface TooltipTriggerProps<Payload = unknown> extends BaseUIComponentProps<'button', TooltipTriggerState> {
|
|
2230
|
+
/**
|
|
2231
|
+
* A handle to associate the trigger with a tooltip.
|
|
2232
|
+
*/
|
|
2233
|
+
handle?: TooltipHandle<Payload> | undefined;
|
|
2234
|
+
/**
|
|
2235
|
+
* A payload to pass to the tooltip when it is opened.
|
|
2236
|
+
*/
|
|
2237
|
+
payload?: Payload | undefined;
|
|
2238
|
+
/**
|
|
2239
|
+
* How long to wait before opening the tooltip on hover. Specified in milliseconds.
|
|
2240
|
+
* @default 600
|
|
2241
|
+
*/
|
|
2242
|
+
delay?: number | undefined;
|
|
2243
|
+
/**
|
|
2244
|
+
* Whether the tooltip should close when this trigger is clicked.
|
|
2245
|
+
* @default true
|
|
2246
|
+
*/
|
|
2247
|
+
closeOnClick?: boolean | undefined;
|
|
2248
|
+
/**
|
|
2249
|
+
* How long to wait before closing the tooltip. Specified in milliseconds.
|
|
2250
|
+
* @default 0
|
|
2251
|
+
*/
|
|
2252
|
+
closeDelay?: number | undefined;
|
|
2253
|
+
/**
|
|
2254
|
+
* If `true`, the tooltip will not open when interacting with this trigger.
|
|
2255
|
+
* Note that this doesn't apply the `disabled` attribute to the trigger element.
|
|
2256
|
+
* If you want to disable the trigger element itself, you can pass the `disabled` prop to the trigger element via the `render` prop.
|
|
2257
|
+
* @default false
|
|
2258
|
+
*/
|
|
2259
|
+
disabled?: boolean | undefined;
|
|
2260
|
+
}
|
|
2261
|
+
declare namespace TooltipTrigger$1 {
|
|
2262
|
+
type State = TooltipTriggerState;
|
|
2263
|
+
type Props<Payload = unknown> = TooltipTriggerProps<Payload>;
|
|
2264
|
+
}
|
|
2265
|
+
//#endregion
|
|
2266
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/tooltip/positioner/TooltipPositioner.d.mts
|
|
2267
|
+
/**
|
|
2268
|
+
* Positions the tooltip against the trigger.
|
|
2269
|
+
* Renders a `<div>` element.
|
|
2270
|
+
*
|
|
2271
|
+
* Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)
|
|
2272
|
+
*/
|
|
2273
|
+
declare const TooltipPositioner: React$1.ForwardRefExoticComponent<Omit<TooltipPositionerProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
|
|
2274
|
+
interface TooltipPositionerState {
|
|
2275
|
+
/**
|
|
2276
|
+
* Whether the tooltip is currently open.
|
|
2277
|
+
*/
|
|
2278
|
+
open: boolean;
|
|
2279
|
+
/**
|
|
2280
|
+
* The side of the anchor the component is placed on.
|
|
2281
|
+
*/
|
|
2282
|
+
side: Side;
|
|
2283
|
+
/**
|
|
2284
|
+
* The alignment of the component relative to the anchor.
|
|
2285
|
+
*/
|
|
2286
|
+
align: Align;
|
|
2287
|
+
/**
|
|
2288
|
+
* Whether the anchor element is hidden.
|
|
2289
|
+
*/
|
|
2290
|
+
anchorHidden: boolean;
|
|
2291
|
+
/**
|
|
2292
|
+
* Whether CSS transitions should be disabled.
|
|
2293
|
+
*/
|
|
2294
|
+
instant: string | undefined;
|
|
2295
|
+
}
|
|
2296
|
+
interface TooltipPositionerProps extends BaseUIComponentProps<'div', TooltipPositionerState>, Omit<UseAnchorPositioningSharedParameters, 'side'> {
|
|
2297
|
+
/**
|
|
2298
|
+
* Which side of the anchor element to align the popup against.
|
|
2299
|
+
* May automatically change to avoid collisions.
|
|
2300
|
+
* @default 'top'
|
|
2301
|
+
*/
|
|
2302
|
+
side?: Side | undefined;
|
|
2303
|
+
}
|
|
2304
|
+
declare namespace TooltipPositioner {
|
|
2305
|
+
type State = TooltipPositionerState;
|
|
2306
|
+
type Props = TooltipPositionerProps;
|
|
2307
|
+
}
|
|
2308
|
+
//#endregion
|
|
2309
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/tooltip/popup/TooltipPopup.d.mts
|
|
2310
|
+
/**
|
|
2311
|
+
* A container for the tooltip contents.
|
|
2312
|
+
* Renders a `<div>` element.
|
|
2313
|
+
*
|
|
2314
|
+
* Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)
|
|
2315
|
+
*/
|
|
2316
|
+
declare const TooltipPopup: React$1.ForwardRefExoticComponent<Omit<TooltipPopupProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
|
|
2317
|
+
interface TooltipPopupState {
|
|
2318
|
+
/**
|
|
2319
|
+
* Whether the tooltip is currently open.
|
|
2320
|
+
*/
|
|
2321
|
+
open: boolean;
|
|
2322
|
+
/**
|
|
2323
|
+
* The side of the anchor the component is placed on.
|
|
2324
|
+
*/
|
|
2325
|
+
side: Side;
|
|
2326
|
+
/**
|
|
2327
|
+
* The alignment of the component relative to the anchor.
|
|
2328
|
+
*/
|
|
2329
|
+
align: Align;
|
|
2330
|
+
/**
|
|
2331
|
+
* Whether transitions should be skipped.
|
|
2332
|
+
*/
|
|
2333
|
+
instant: 'delay' | 'focus' | 'dismiss' | undefined;
|
|
2334
|
+
/**
|
|
2335
|
+
* The transition status of the component.
|
|
2336
|
+
*/
|
|
2337
|
+
transitionStatus: TransitionStatus;
|
|
2338
|
+
}
|
|
2339
|
+
interface TooltipPopupProps extends BaseUIComponentProps<'div', TooltipPopupState> {}
|
|
2340
|
+
declare namespace TooltipPopup {
|
|
2341
|
+
type State = TooltipPopupState;
|
|
2342
|
+
type Props = TooltipPopupProps;
|
|
2343
|
+
}
|
|
2344
|
+
//#endregion
|
|
2345
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/tooltip/provider/TooltipProvider.d.mts
|
|
2346
|
+
/**
|
|
2347
|
+
* Provides a shared delay for multiple tooltips. The grouping logic ensures that
|
|
2348
|
+
* once a tooltip becomes visible, the adjacent tooltips will be shown instantly.
|
|
2349
|
+
*
|
|
2350
|
+
* Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)
|
|
2351
|
+
*/
|
|
2352
|
+
declare const TooltipProvider$1: React$1.FC<TooltipProvider$1.Props>;
|
|
2353
|
+
interface TooltipProviderState {}
|
|
2354
|
+
interface TooltipProviderProps {
|
|
2355
|
+
children?: React$1.ReactNode;
|
|
2356
|
+
/**
|
|
2357
|
+
* How long to wait before opening the tooltip on hover. Specified in milliseconds.
|
|
2358
|
+
*/
|
|
2359
|
+
delay?: number | undefined;
|
|
2360
|
+
/**
|
|
2361
|
+
* How long to wait before closing a tooltip. Specified in milliseconds.
|
|
2362
|
+
*/
|
|
2363
|
+
closeDelay?: number | undefined;
|
|
2364
|
+
/**
|
|
2365
|
+
* Another tooltip will open instantly if the previous tooltip
|
|
2366
|
+
* is closed within this timeout. Specified in milliseconds.
|
|
2367
|
+
* @default 400
|
|
2368
|
+
*/
|
|
2369
|
+
timeout?: number | undefined;
|
|
2370
|
+
}
|
|
2371
|
+
declare namespace TooltipProvider$1 {
|
|
2372
|
+
type State = TooltipProviderState;
|
|
2373
|
+
type Props = TooltipProviderProps;
|
|
2374
|
+
}
|
|
2375
|
+
//#endregion
|
|
2376
|
+
//#region ../../node_modules/.bun/@base-ui+utils@0.5.0+2fde69a3fd50c568/node_modules/@base-ui/utils/useTimeout.d.mts
|
|
2377
|
+
type TimeoutId = number;
|
|
2378
|
+
declare class Timeout {
|
|
2379
|
+
static create(): Timeout;
|
|
2380
|
+
currentId: TimeoutId;
|
|
2381
|
+
/**
|
|
2382
|
+
* Executes `fn` after `delay`, clearing any previously scheduled call.
|
|
2383
|
+
*/
|
|
2384
|
+
start(delay: number, fn: Function): void;
|
|
2385
|
+
isStarted(): boolean;
|
|
2386
|
+
clear: () => void;
|
|
2387
|
+
disposeEffect: () => () => void;
|
|
2388
|
+
}
|
|
2389
|
+
//#endregion
|
|
2390
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/popover/store/PopoverStore.d.mts
|
|
2391
|
+
type State<Payload> = PopupStoreState<Payload> & {
|
|
2392
|
+
disabled: boolean;
|
|
2393
|
+
instantType: 'dismiss' | 'click' | 'focus' | 'trigger-change' | undefined;
|
|
2394
|
+
modal: boolean | 'trap-focus';
|
|
2395
|
+
focusManagerModal: boolean;
|
|
2396
|
+
openMethod: InteractionType | null;
|
|
2397
|
+
openChangeReason: PopoverRoot.ChangeEventReason | null;
|
|
2398
|
+
titleElementId: string | undefined;
|
|
2399
|
+
descriptionElementId: string | undefined;
|
|
2400
|
+
openOnHover: boolean;
|
|
2401
|
+
closeDelay: number;
|
|
2402
|
+
adaptiveOrigin: AdaptiveOriginMiddleware | undefined;
|
|
2403
|
+
};
|
|
2404
|
+
type Context = PopupStoreContext<PopoverRoot.ChangeEventDetails> & {
|
|
2405
|
+
readonly popupRef: React$1.RefObject<HTMLElement | null>;
|
|
2406
|
+
readonly triggerFocusTargetRef: React$1.RefObject<HTMLElement | null>;
|
|
2407
|
+
readonly beforeTriggerFocusGuardRef: React$1.RefObject<HTMLElement | null>;
|
|
2408
|
+
readonly beforeContentFocusGuardRef: React$1.RefObject<HTMLElement | null>;
|
|
2409
|
+
readonly stickIfOpenTimeout: Timeout;
|
|
2410
|
+
stickIfOpen: boolean;
|
|
2411
|
+
};
|
|
2412
|
+
declare const selectors: {
|
|
2413
|
+
open: (state: {
|
|
2414
|
+
open: boolean;
|
|
2415
|
+
readonly openProp: boolean | undefined;
|
|
2416
|
+
mounted: boolean;
|
|
2417
|
+
transitionStatus: TransitionStatus;
|
|
2418
|
+
floatingRootContext: FloatingRootContext;
|
|
2419
|
+
floatingId: string | undefined;
|
|
2420
|
+
triggerCount: number;
|
|
2421
|
+
preventUnmountingOnClose: boolean;
|
|
2422
|
+
payload: unknown;
|
|
2423
|
+
activeTriggerId: string | null;
|
|
2424
|
+
activeTriggerElement: Element | null;
|
|
2425
|
+
openedWithoutTrigger: boolean;
|
|
2426
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2427
|
+
popupElement: HTMLElement | null;
|
|
2428
|
+
positionerElement: HTMLElement | null;
|
|
2429
|
+
activeTriggerProps: HTMLProps;
|
|
2430
|
+
inactiveTriggerProps: HTMLProps;
|
|
2431
|
+
popupProps: HTMLProps;
|
|
2432
|
+
}) => boolean;
|
|
2433
|
+
mounted: (state: {
|
|
2434
|
+
open: boolean;
|
|
2435
|
+
readonly openProp: boolean | undefined;
|
|
2436
|
+
mounted: boolean;
|
|
2437
|
+
transitionStatus: TransitionStatus;
|
|
2438
|
+
floatingRootContext: FloatingRootContext;
|
|
2439
|
+
floatingId: string | undefined;
|
|
2440
|
+
triggerCount: number;
|
|
2441
|
+
preventUnmountingOnClose: boolean;
|
|
2442
|
+
payload: unknown;
|
|
2443
|
+
activeTriggerId: string | null;
|
|
2444
|
+
activeTriggerElement: Element | null;
|
|
2445
|
+
openedWithoutTrigger: boolean;
|
|
2446
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2447
|
+
popupElement: HTMLElement | null;
|
|
2448
|
+
positionerElement: HTMLElement | null;
|
|
2449
|
+
activeTriggerProps: HTMLProps;
|
|
2450
|
+
inactiveTriggerProps: HTMLProps;
|
|
2451
|
+
popupProps: HTMLProps;
|
|
2452
|
+
}) => boolean;
|
|
2453
|
+
transitionStatus: (state: {
|
|
2454
|
+
open: boolean;
|
|
2455
|
+
readonly openProp: boolean | undefined;
|
|
2456
|
+
mounted: boolean;
|
|
2457
|
+
transitionStatus: TransitionStatus;
|
|
2458
|
+
floatingRootContext: FloatingRootContext;
|
|
2459
|
+
floatingId: string | undefined;
|
|
2460
|
+
triggerCount: number;
|
|
2461
|
+
preventUnmountingOnClose: boolean;
|
|
2462
|
+
payload: unknown;
|
|
2463
|
+
activeTriggerId: string | null;
|
|
2464
|
+
activeTriggerElement: Element | null;
|
|
2465
|
+
openedWithoutTrigger: boolean;
|
|
2466
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2467
|
+
popupElement: HTMLElement | null;
|
|
2468
|
+
positionerElement: HTMLElement | null;
|
|
2469
|
+
activeTriggerProps: HTMLProps;
|
|
2470
|
+
inactiveTriggerProps: HTMLProps;
|
|
2471
|
+
popupProps: HTMLProps;
|
|
2472
|
+
}) => TransitionStatus;
|
|
2473
|
+
floatingRootContext: (state: {
|
|
2474
|
+
open: boolean;
|
|
2475
|
+
readonly openProp: boolean | undefined;
|
|
2476
|
+
mounted: boolean;
|
|
2477
|
+
transitionStatus: TransitionStatus;
|
|
2478
|
+
floatingRootContext: FloatingRootContext;
|
|
2479
|
+
floatingId: string | undefined;
|
|
2480
|
+
triggerCount: number;
|
|
2481
|
+
preventUnmountingOnClose: boolean;
|
|
2482
|
+
payload: unknown;
|
|
2483
|
+
activeTriggerId: string | null;
|
|
2484
|
+
activeTriggerElement: Element | null;
|
|
2485
|
+
openedWithoutTrigger: boolean;
|
|
2486
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2487
|
+
popupElement: HTMLElement | null;
|
|
2488
|
+
positionerElement: HTMLElement | null;
|
|
2489
|
+
activeTriggerProps: HTMLProps;
|
|
2490
|
+
inactiveTriggerProps: HTMLProps;
|
|
2491
|
+
popupProps: HTMLProps;
|
|
2492
|
+
}) => FloatingRootStore;
|
|
2493
|
+
triggerCount: (state: {
|
|
2494
|
+
open: boolean;
|
|
2495
|
+
readonly openProp: boolean | undefined;
|
|
2496
|
+
mounted: boolean;
|
|
2497
|
+
transitionStatus: TransitionStatus;
|
|
2498
|
+
floatingRootContext: FloatingRootContext;
|
|
2499
|
+
floatingId: string | undefined;
|
|
2500
|
+
triggerCount: number;
|
|
2501
|
+
preventUnmountingOnClose: boolean;
|
|
2502
|
+
payload: unknown;
|
|
2503
|
+
activeTriggerId: string | null;
|
|
2504
|
+
activeTriggerElement: Element | null;
|
|
2505
|
+
openedWithoutTrigger: boolean;
|
|
2506
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2507
|
+
popupElement: HTMLElement | null;
|
|
2508
|
+
positionerElement: HTMLElement | null;
|
|
2509
|
+
activeTriggerProps: HTMLProps;
|
|
2510
|
+
inactiveTriggerProps: HTMLProps;
|
|
2511
|
+
popupProps: HTMLProps;
|
|
2512
|
+
}) => number;
|
|
2513
|
+
preventUnmountingOnClose: (state: {
|
|
2514
|
+
open: boolean;
|
|
2515
|
+
readonly openProp: boolean | undefined;
|
|
2516
|
+
mounted: boolean;
|
|
2517
|
+
transitionStatus: TransitionStatus;
|
|
2518
|
+
floatingRootContext: FloatingRootContext;
|
|
2519
|
+
floatingId: string | undefined;
|
|
2520
|
+
triggerCount: number;
|
|
2521
|
+
preventUnmountingOnClose: boolean;
|
|
2522
|
+
payload: unknown;
|
|
2523
|
+
activeTriggerId: string | null;
|
|
2524
|
+
activeTriggerElement: Element | null;
|
|
2525
|
+
openedWithoutTrigger: boolean;
|
|
2526
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2527
|
+
popupElement: HTMLElement | null;
|
|
2528
|
+
positionerElement: HTMLElement | null;
|
|
2529
|
+
activeTriggerProps: HTMLProps;
|
|
2530
|
+
inactiveTriggerProps: HTMLProps;
|
|
2531
|
+
popupProps: HTMLProps;
|
|
2532
|
+
}) => boolean;
|
|
2533
|
+
payload: (state: {
|
|
2534
|
+
open: boolean;
|
|
2535
|
+
readonly openProp: boolean | undefined;
|
|
2536
|
+
mounted: boolean;
|
|
2537
|
+
transitionStatus: TransitionStatus;
|
|
2538
|
+
floatingRootContext: FloatingRootContext;
|
|
2539
|
+
floatingId: string | undefined;
|
|
2540
|
+
triggerCount: number;
|
|
2541
|
+
preventUnmountingOnClose: boolean;
|
|
2542
|
+
payload: unknown;
|
|
2543
|
+
activeTriggerId: string | null;
|
|
2544
|
+
activeTriggerElement: Element | null;
|
|
2545
|
+
openedWithoutTrigger: boolean;
|
|
2546
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2547
|
+
popupElement: HTMLElement | null;
|
|
2548
|
+
positionerElement: HTMLElement | null;
|
|
2549
|
+
activeTriggerProps: HTMLProps;
|
|
2550
|
+
inactiveTriggerProps: HTMLProps;
|
|
2551
|
+
popupProps: HTMLProps;
|
|
2552
|
+
}) => unknown;
|
|
2553
|
+
activeTriggerId: (state: {
|
|
2554
|
+
open: boolean;
|
|
2555
|
+
readonly openProp: boolean | undefined;
|
|
2556
|
+
mounted: boolean;
|
|
2557
|
+
transitionStatus: TransitionStatus;
|
|
2558
|
+
floatingRootContext: FloatingRootContext;
|
|
2559
|
+
floatingId: string | undefined;
|
|
2560
|
+
triggerCount: number;
|
|
2561
|
+
preventUnmountingOnClose: boolean;
|
|
2562
|
+
payload: unknown;
|
|
2563
|
+
activeTriggerId: string | null;
|
|
2564
|
+
activeTriggerElement: Element | null;
|
|
2565
|
+
openedWithoutTrigger: boolean;
|
|
2566
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2567
|
+
popupElement: HTMLElement | null;
|
|
2568
|
+
positionerElement: HTMLElement | null;
|
|
2569
|
+
activeTriggerProps: HTMLProps;
|
|
2570
|
+
inactiveTriggerProps: HTMLProps;
|
|
2571
|
+
popupProps: HTMLProps;
|
|
2572
|
+
}) => string | null;
|
|
2573
|
+
activeTriggerElement: (state: {
|
|
2574
|
+
open: boolean;
|
|
2575
|
+
readonly openProp: boolean | undefined;
|
|
2576
|
+
mounted: boolean;
|
|
2577
|
+
transitionStatus: TransitionStatus;
|
|
2578
|
+
floatingRootContext: FloatingRootContext;
|
|
2579
|
+
floatingId: string | undefined;
|
|
2580
|
+
triggerCount: number;
|
|
2581
|
+
preventUnmountingOnClose: boolean;
|
|
2582
|
+
payload: unknown;
|
|
2583
|
+
activeTriggerId: string | null;
|
|
2584
|
+
activeTriggerElement: Element | null;
|
|
2585
|
+
openedWithoutTrigger: boolean;
|
|
2586
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2587
|
+
popupElement: HTMLElement | null;
|
|
2588
|
+
positionerElement: HTMLElement | null;
|
|
2589
|
+
activeTriggerProps: HTMLProps;
|
|
2590
|
+
inactiveTriggerProps: HTMLProps;
|
|
2591
|
+
popupProps: HTMLProps;
|
|
2592
|
+
}) => Element | null;
|
|
2593
|
+
popupId: (state: {
|
|
2594
|
+
open: boolean;
|
|
2595
|
+
readonly openProp: boolean | undefined;
|
|
2596
|
+
mounted: boolean;
|
|
2597
|
+
transitionStatus: TransitionStatus;
|
|
2598
|
+
floatingRootContext: FloatingRootContext;
|
|
2599
|
+
floatingId: string | undefined;
|
|
2600
|
+
triggerCount: number;
|
|
2601
|
+
preventUnmountingOnClose: boolean;
|
|
2602
|
+
payload: unknown;
|
|
2603
|
+
activeTriggerId: string | null;
|
|
2604
|
+
activeTriggerElement: Element | null;
|
|
2605
|
+
openedWithoutTrigger: boolean;
|
|
2606
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2607
|
+
popupElement: HTMLElement | null;
|
|
2608
|
+
positionerElement: HTMLElement | null;
|
|
2609
|
+
activeTriggerProps: HTMLProps;
|
|
2610
|
+
inactiveTriggerProps: HTMLProps;
|
|
2611
|
+
popupProps: HTMLProps;
|
|
2612
|
+
}) => string | undefined;
|
|
2613
|
+
isTriggerActive: (state: {
|
|
2614
|
+
open: boolean;
|
|
2615
|
+
readonly openProp: boolean | undefined;
|
|
2616
|
+
mounted: boolean;
|
|
2617
|
+
transitionStatus: TransitionStatus;
|
|
2618
|
+
floatingRootContext: FloatingRootContext;
|
|
2619
|
+
floatingId: string | undefined;
|
|
2620
|
+
triggerCount: number;
|
|
2621
|
+
preventUnmountingOnClose: boolean;
|
|
2622
|
+
payload: unknown;
|
|
2623
|
+
activeTriggerId: string | null;
|
|
2624
|
+
activeTriggerElement: Element | null;
|
|
2625
|
+
openedWithoutTrigger: boolean;
|
|
2626
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2627
|
+
popupElement: HTMLElement | null;
|
|
2628
|
+
positionerElement: HTMLElement | null;
|
|
2629
|
+
activeTriggerProps: HTMLProps;
|
|
2630
|
+
inactiveTriggerProps: HTMLProps;
|
|
2631
|
+
popupProps: HTMLProps;
|
|
2632
|
+
}, triggerId: string | undefined) => boolean;
|
|
2633
|
+
isOpenedByTrigger: (state: {
|
|
2634
|
+
open: boolean;
|
|
2635
|
+
readonly openProp: boolean | undefined;
|
|
2636
|
+
mounted: boolean;
|
|
2637
|
+
transitionStatus: TransitionStatus;
|
|
2638
|
+
floatingRootContext: FloatingRootContext;
|
|
2639
|
+
floatingId: string | undefined;
|
|
2640
|
+
triggerCount: number;
|
|
2641
|
+
preventUnmountingOnClose: boolean;
|
|
2642
|
+
payload: unknown;
|
|
2643
|
+
activeTriggerId: string | null;
|
|
2644
|
+
activeTriggerElement: Element | null;
|
|
2645
|
+
openedWithoutTrigger: boolean;
|
|
2646
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2647
|
+
popupElement: HTMLElement | null;
|
|
2648
|
+
positionerElement: HTMLElement | null;
|
|
2649
|
+
activeTriggerProps: HTMLProps;
|
|
2650
|
+
inactiveTriggerProps: HTMLProps;
|
|
2651
|
+
popupProps: HTMLProps;
|
|
2652
|
+
}, triggerId: string | undefined) => boolean;
|
|
2653
|
+
isMountedByTrigger: (state: {
|
|
2654
|
+
open: boolean;
|
|
2655
|
+
readonly openProp: boolean | undefined;
|
|
2656
|
+
mounted: boolean;
|
|
2657
|
+
transitionStatus: TransitionStatus;
|
|
2658
|
+
floatingRootContext: FloatingRootContext;
|
|
2659
|
+
floatingId: string | undefined;
|
|
2660
|
+
triggerCount: number;
|
|
2661
|
+
preventUnmountingOnClose: boolean;
|
|
2662
|
+
payload: unknown;
|
|
2663
|
+
activeTriggerId: string | null;
|
|
2664
|
+
activeTriggerElement: Element | null;
|
|
2665
|
+
openedWithoutTrigger: boolean;
|
|
2666
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2667
|
+
popupElement: HTMLElement | null;
|
|
2668
|
+
positionerElement: HTMLElement | null;
|
|
2669
|
+
activeTriggerProps: HTMLProps;
|
|
2670
|
+
inactiveTriggerProps: HTMLProps;
|
|
2671
|
+
popupProps: HTMLProps;
|
|
2672
|
+
}, triggerId: string | undefined) => boolean;
|
|
2673
|
+
triggerProps: (state: {
|
|
2674
|
+
open: boolean;
|
|
2675
|
+
readonly openProp: boolean | undefined;
|
|
2676
|
+
mounted: boolean;
|
|
2677
|
+
transitionStatus: TransitionStatus;
|
|
2678
|
+
floatingRootContext: FloatingRootContext;
|
|
2679
|
+
floatingId: string | undefined;
|
|
2680
|
+
triggerCount: number;
|
|
2681
|
+
preventUnmountingOnClose: boolean;
|
|
2682
|
+
payload: unknown;
|
|
2683
|
+
activeTriggerId: string | null;
|
|
2684
|
+
activeTriggerElement: Element | null;
|
|
2685
|
+
openedWithoutTrigger: boolean;
|
|
2686
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2687
|
+
popupElement: HTMLElement | null;
|
|
2688
|
+
positionerElement: HTMLElement | null;
|
|
2689
|
+
activeTriggerProps: HTMLProps;
|
|
2690
|
+
inactiveTriggerProps: HTMLProps;
|
|
2691
|
+
popupProps: HTMLProps;
|
|
2692
|
+
}, isActive: boolean) => HTMLProps;
|
|
2693
|
+
triggerPopupId: (state: {
|
|
2694
|
+
open: boolean;
|
|
2695
|
+
readonly openProp: boolean | undefined;
|
|
2696
|
+
mounted: boolean;
|
|
2697
|
+
transitionStatus: TransitionStatus;
|
|
2698
|
+
floatingRootContext: FloatingRootContext;
|
|
2699
|
+
floatingId: string | undefined;
|
|
2700
|
+
triggerCount: number;
|
|
2701
|
+
preventUnmountingOnClose: boolean;
|
|
2702
|
+
payload: unknown;
|
|
2703
|
+
activeTriggerId: string | null;
|
|
2704
|
+
activeTriggerElement: Element | null;
|
|
2705
|
+
openedWithoutTrigger: boolean;
|
|
2706
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2707
|
+
popupElement: HTMLElement | null;
|
|
2708
|
+
positionerElement: HTMLElement | null;
|
|
2709
|
+
activeTriggerProps: HTMLProps;
|
|
2710
|
+
inactiveTriggerProps: HTMLProps;
|
|
2711
|
+
popupProps: HTMLProps;
|
|
2712
|
+
}, triggerId: string | undefined) => string | undefined;
|
|
2713
|
+
popupProps: (state: {
|
|
2714
|
+
open: boolean;
|
|
2715
|
+
readonly openProp: boolean | undefined;
|
|
2716
|
+
mounted: boolean;
|
|
2717
|
+
transitionStatus: TransitionStatus;
|
|
2718
|
+
floatingRootContext: FloatingRootContext;
|
|
2719
|
+
floatingId: string | undefined;
|
|
2720
|
+
triggerCount: number;
|
|
2721
|
+
preventUnmountingOnClose: boolean;
|
|
2722
|
+
payload: unknown;
|
|
2723
|
+
activeTriggerId: string | null;
|
|
2724
|
+
activeTriggerElement: Element | null;
|
|
2725
|
+
openedWithoutTrigger: boolean;
|
|
2726
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2727
|
+
popupElement: HTMLElement | null;
|
|
2728
|
+
positionerElement: HTMLElement | null;
|
|
2729
|
+
activeTriggerProps: HTMLProps;
|
|
2730
|
+
inactiveTriggerProps: HTMLProps;
|
|
2731
|
+
popupProps: HTMLProps;
|
|
2732
|
+
}) => HTMLProps;
|
|
2733
|
+
popupElement: (state: {
|
|
2734
|
+
open: boolean;
|
|
2735
|
+
readonly openProp: boolean | undefined;
|
|
2736
|
+
mounted: boolean;
|
|
2737
|
+
transitionStatus: TransitionStatus;
|
|
2738
|
+
floatingRootContext: FloatingRootContext;
|
|
2739
|
+
floatingId: string | undefined;
|
|
2740
|
+
triggerCount: number;
|
|
2741
|
+
preventUnmountingOnClose: boolean;
|
|
2742
|
+
payload: unknown;
|
|
2743
|
+
activeTriggerId: string | null;
|
|
2744
|
+
activeTriggerElement: Element | null;
|
|
2745
|
+
openedWithoutTrigger: boolean;
|
|
2746
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2747
|
+
popupElement: HTMLElement | null;
|
|
2748
|
+
positionerElement: HTMLElement | null;
|
|
2749
|
+
activeTriggerProps: HTMLProps;
|
|
2750
|
+
inactiveTriggerProps: HTMLProps;
|
|
2751
|
+
popupProps: HTMLProps;
|
|
2752
|
+
}) => HTMLElement | null;
|
|
2753
|
+
positionerElement: (state: {
|
|
2754
|
+
open: boolean;
|
|
2755
|
+
readonly openProp: boolean | undefined;
|
|
2756
|
+
mounted: boolean;
|
|
2757
|
+
transitionStatus: TransitionStatus;
|
|
2758
|
+
floatingRootContext: FloatingRootContext;
|
|
2759
|
+
floatingId: string | undefined;
|
|
2760
|
+
triggerCount: number;
|
|
2761
|
+
preventUnmountingOnClose: boolean;
|
|
2762
|
+
payload: unknown;
|
|
2763
|
+
activeTriggerId: string | null;
|
|
2764
|
+
activeTriggerElement: Element | null;
|
|
2765
|
+
openedWithoutTrigger: boolean;
|
|
2766
|
+
readonly triggerIdProp: string | null | undefined;
|
|
2767
|
+
popupElement: HTMLElement | null;
|
|
2768
|
+
positionerElement: HTMLElement | null;
|
|
2769
|
+
activeTriggerProps: HTMLProps;
|
|
2770
|
+
inactiveTriggerProps: HTMLProps;
|
|
2771
|
+
popupProps: HTMLProps;
|
|
2772
|
+
}) => HTMLElement | null;
|
|
2773
|
+
disabled: (state: State<unknown>) => boolean;
|
|
2774
|
+
instantType: (state: State<unknown>) => "click" | "dismiss" | "focus" | "trigger-change" | undefined;
|
|
2775
|
+
openMethod: (state: State<unknown>) => InteractionType | null;
|
|
2776
|
+
openChangeReason: (state: State<unknown>) => PopoverRootChangeEventReason | null;
|
|
2777
|
+
isPressOpenedByTrigger: (state: State<unknown>, triggerId: string | undefined) => boolean;
|
|
2778
|
+
isTouchPressOpen: (state: State<unknown>, openOnHover: boolean) => boolean;
|
|
2779
|
+
hasTriggerFocusGuards: (state: State<unknown>, triggerId: string | undefined) => boolean;
|
|
2780
|
+
modal: (state: State<unknown>) => "trap-focus" | boolean;
|
|
2781
|
+
titleElementId: (state: State<unknown>) => string | undefined;
|
|
2782
|
+
descriptionElementId: (state: State<unknown>) => string | undefined;
|
|
2783
|
+
openOnHover: (state: State<unknown>) => boolean;
|
|
2784
|
+
closeDelay: (state: State<unknown>) => number;
|
|
2785
|
+
adaptiveOrigin: (state: State<unknown>) => AdaptiveOriginMiddleware | undefined;
|
|
2786
|
+
};
|
|
2787
|
+
type Selectors = typeof selectors;
|
|
2788
|
+
/**
|
|
2789
|
+
* The store view that detached handle-backed triggers read from. Both the real `PopoverStore` and
|
|
2790
|
+
* the inert fallback store satisfy it, so a trigger can read from whichever store the handle
|
|
2791
|
+
* currently exposes. Narrowed to the members a trigger actually uses — the trigger-data members plus
|
|
2792
|
+
* `setOpen` (called by the focus guards) — so the exposed surface can't bypass the open-change
|
|
2793
|
+
* pipeline; on the detached fallback store every one of these mutations is a no-op.
|
|
2794
|
+
*/
|
|
2795
|
+
type PopoverHandleStore<Payload> = Pick<PopoverStore<Payload>, PopupTriggerStoreKeys | 'setOpen'>;
|
|
2796
|
+
declare class PopoverStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, Selectors> {
|
|
2797
|
+
constructor(initialState: Partial<State<Payload>>, floatingId: string | undefined, nested: boolean);
|
|
2798
|
+
setOpen: (nextOpen: boolean, eventDetails: Omit<PopoverRoot.ChangeEventDetails, 'preventUnmountOnClose'>) => void;
|
|
2799
|
+
}
|
|
2800
|
+
//#endregion
|
|
2801
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/popover/store/PopoverHandle.d.mts
|
|
2802
|
+
/**
|
|
2803
|
+
* Controls a Popover imperatively and associates detached `Popover.Trigger` components with a
|
|
2804
|
+
* `Popover.Root`. Create one with `Popover.createHandle()` and pass it to the `handle` prop of the
|
|
2805
|
+
* root and of any triggers rendered outside of it.
|
|
2806
|
+
*
|
|
2807
|
+
* The imperative methods take effect only while a root using this handle is mounted; calls made
|
|
2808
|
+
* before a root attaches (or after it unmounts) are ignored.
|
|
2809
|
+
*/
|
|
2810
|
+
declare class PopoverHandle<Payload> extends BasePopupHandle<PopoverHandleStore<Payload>, PopoverStore<Payload>> {
|
|
2811
|
+
constructor();
|
|
2812
|
+
/**
|
|
2813
|
+
* Opens the popover and associates it with the trigger with the given id.
|
|
2814
|
+
*
|
|
2815
|
+
* This method should only be called in an event handler or an effect (not during rendering).
|
|
2816
|
+
*
|
|
2817
|
+
* @param triggerId ID of the trigger to associate with the popover. The trigger must be a matching
|
|
2818
|
+
* `Popover.Trigger` with this handle passed as a prop.
|
|
2819
|
+
*/
|
|
2820
|
+
open(triggerId: string): void;
|
|
2821
|
+
/**
|
|
2822
|
+
* Closes the popover.
|
|
2823
|
+
*
|
|
2824
|
+
* This method should only be called in an event handler or an effect (not during rendering).
|
|
2825
|
+
*/
|
|
2826
|
+
close(): void;
|
|
2827
|
+
/**
|
|
2828
|
+
* Whether the popover is currently open. Returns `false` while no root is attached to the handle.
|
|
2829
|
+
*/
|
|
2830
|
+
get isOpen(): boolean;
|
|
2831
|
+
}
|
|
2832
|
+
//#endregion
|
|
2833
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/popover/root/PopoverRoot.d.mts
|
|
2834
|
+
/**
|
|
2835
|
+
* Groups all parts of the popover.
|
|
2836
|
+
* Doesn't render its own HTML element.
|
|
2837
|
+
*
|
|
2838
|
+
* Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
|
|
2839
|
+
*/
|
|
2840
|
+
declare function PopoverRoot<Payload = unknown>(props: PopoverRoot.Props<Payload>): React$1.JSX.Element;
|
|
2841
|
+
interface PopoverRootState {}
|
|
2842
|
+
interface PopoverRootProps<Payload = unknown> {
|
|
2843
|
+
/**
|
|
2844
|
+
* Whether the popover is initially open.
|
|
2845
|
+
*
|
|
2846
|
+
* To render a controlled popover, use the `open` prop instead.
|
|
2847
|
+
* @default false
|
|
2848
|
+
*/
|
|
2849
|
+
defaultOpen?: boolean | undefined;
|
|
2850
|
+
/**
|
|
2851
|
+
* Whether the popover is currently open.
|
|
2852
|
+
*/
|
|
2853
|
+
open?: boolean | undefined;
|
|
2854
|
+
/**
|
|
2855
|
+
* Event handler called when the popover is opened or closed.
|
|
2856
|
+
*/
|
|
2857
|
+
onOpenChange?: ((open: boolean, eventDetails: PopoverRoot.ChangeEventDetails) => void) | undefined;
|
|
2858
|
+
/**
|
|
2859
|
+
* Event handler called after any animations complete when the popover is opened or closed.
|
|
2860
|
+
*/
|
|
2861
|
+
onOpenChangeComplete?: ((open: boolean) => void) | undefined;
|
|
2862
|
+
/**
|
|
2863
|
+
* A ref to imperative actions.
|
|
2864
|
+
* - `unmount`: Ends the closing phase of the popover after an externally controlled closing animation finishes.
|
|
2865
|
+
* Call `preventUnmountOnClose()` in `onOpenChange` first, otherwise the popover completes closing on its own.
|
|
2866
|
+
* Whether it leaves the DOM is decided by `keepMounted` on the portal.
|
|
2867
|
+
* - `close`: Closes the popover imperatively when called.
|
|
2868
|
+
*/
|
|
2869
|
+
actionsRef?: React$1.RefObject<PopoverRoot.Actions | null> | undefined;
|
|
2870
|
+
/**
|
|
2871
|
+
* Determines if the popover enters a modal state when open.
|
|
2872
|
+
* - `true`: user interaction is limited to the popover: document page scroll is locked, and pointer interactions on outside elements are disabled.
|
|
2873
|
+
* - `false`: user interaction with the rest of the document is allowed.
|
|
2874
|
+
* - `'trap-focus'`: focus is trapped inside the popover, but document page scroll is not locked and pointer interactions outside of it remain enabled.
|
|
2875
|
+
*
|
|
2876
|
+
* On touch devices, a `true` modal blocks outside taps but leaves the page scrollable unless the popup spans nearly the full viewport width, matching native iOS behavior.
|
|
2877
|
+
*
|
|
2878
|
+
* When `modal` is `true`, focus trapping is enabled only if `<Popover.Close>` is rendered
|
|
2879
|
+
* inside `<Popover.Popup>`. It can be visually hidden with your own CSS if needed, such as
|
|
2880
|
+
* Tailwind's `sr-only` utility.
|
|
2881
|
+
*
|
|
2882
|
+
* When `modal` is `'trap-focus'`, render `<Popover.Close>` inside `<Popover.Popup>` so touch
|
|
2883
|
+
* screen readers can escape the popup.
|
|
2884
|
+
* @default false
|
|
2885
|
+
*/
|
|
2886
|
+
modal?: boolean | 'trap-focus' | undefined;
|
|
2887
|
+
/**
|
|
2888
|
+
* ID of the trigger that the popover is associated with.
|
|
2889
|
+
* This is useful in conjunction with the `open` prop to create a controlled popover.
|
|
2890
|
+
* There's no need to specify this prop when the popover is uncontrolled (that is, when the `open` prop is not set).
|
|
2891
|
+
*/
|
|
2892
|
+
triggerId?: string | null | undefined;
|
|
2893
|
+
/**
|
|
2894
|
+
* ID of the trigger that the popover is associated with.
|
|
2895
|
+
* This is useful in conjunction with the `defaultOpen` prop to create an initially open popover.
|
|
2896
|
+
*/
|
|
2897
|
+
defaultTriggerId?: string | null | undefined;
|
|
2898
|
+
/**
|
|
2899
|
+
* A handle to associate the popover with a trigger.
|
|
2900
|
+
* If specified, allows external triggers to control the popover's open state.
|
|
2901
|
+
*/
|
|
2902
|
+
handle?: PopoverHandle<Payload> | undefined;
|
|
2903
|
+
/**
|
|
2904
|
+
* The content of the popover.
|
|
2905
|
+
* This can be a regular React node or a render function that receives the `payload` of the active trigger.
|
|
2906
|
+
*/
|
|
2907
|
+
children?: React$1.ReactNode | PayloadChildRenderFunction<Payload>;
|
|
2908
|
+
}
|
|
2909
|
+
interface PopoverRootActions {
|
|
2910
|
+
unmount: () => void;
|
|
2911
|
+
close: () => void;
|
|
2912
|
+
}
|
|
2913
|
+
type PopoverRootChangeEventReason = typeof triggerHover | typeof triggerFocus | typeof triggerPress | typeof outsidePress | typeof escapeKey | typeof closePress | typeof focusOut | typeof imperativeAction | typeof none;
|
|
2914
|
+
type PopoverRootChangeEventDetails = BaseUIChangeEventDetails<PopoverRoot.ChangeEventReason> & {
|
|
2915
|
+
/** Prevents the popup from unmounting until the `unmount` action is called. */
|
|
2916
|
+
preventUnmountOnClose: () => void;
|
|
2917
|
+
};
|
|
2918
|
+
declare namespace PopoverRoot {
|
|
2919
|
+
type State = PopoverRootState;
|
|
2920
|
+
type Props<Payload = unknown> = PopoverRootProps<Payload>;
|
|
2921
|
+
type Actions = PopoverRootActions;
|
|
2922
|
+
type ChangeEventReason = PopoverRootChangeEventReason;
|
|
2923
|
+
type ChangeEventDetails = PopoverRootChangeEventDetails;
|
|
2924
|
+
}
|
|
2925
|
+
//#endregion
|
|
2926
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/popover/trigger/PopoverTrigger.d.mts
|
|
2927
|
+
/**
|
|
2928
|
+
* A button that opens the popover.
|
|
2929
|
+
* Renders a `<button>` element.
|
|
2930
|
+
*
|
|
2931
|
+
* Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
|
|
2932
|
+
*/
|
|
2933
|
+
declare const PopoverTrigger$1: PopoverTrigger$1;
|
|
2934
|
+
interface PopoverTrigger$1 {
|
|
2935
|
+
<Payload>(componentProps: PopoverTriggerProps<Payload> & React$1.RefAttributes<HTMLElement>): React$1.JSX.Element;
|
|
2936
|
+
}
|
|
2937
|
+
interface PopoverTriggerState {
|
|
2938
|
+
/**
|
|
2939
|
+
* Whether the trigger is currently disabled.
|
|
2940
|
+
*/
|
|
2941
|
+
disabled: boolean;
|
|
2942
|
+
/**
|
|
2943
|
+
* Whether the popover is currently open and was opened by this trigger.
|
|
2944
|
+
*/
|
|
2945
|
+
open: boolean;
|
|
2946
|
+
}
|
|
2947
|
+
type PopoverTriggerProps<Payload = unknown> = NativeButtonProps & BaseUIComponentProps<'button', PopoverTriggerState> & {
|
|
2948
|
+
/**
|
|
2949
|
+
* Whether the component renders a native `<button>` element when replacing it
|
|
2950
|
+
* via the `render` prop.
|
|
2951
|
+
* Set to `false` if the rendered element is not a button (e.g. `<div>`).
|
|
2952
|
+
* @default true
|
|
2953
|
+
*/
|
|
2954
|
+
nativeButton?: boolean | undefined;
|
|
2955
|
+
/**
|
|
2956
|
+
* A handle to associate the trigger with a popover.
|
|
2957
|
+
*/
|
|
2958
|
+
handle?: PopoverHandle<Payload> | undefined;
|
|
2959
|
+
/**
|
|
2960
|
+
* A payload to pass to the popover when it is opened.
|
|
2961
|
+
*/
|
|
2962
|
+
payload?: Payload | undefined;
|
|
2963
|
+
/**
|
|
2964
|
+
* ID of the trigger. In addition to being forwarded to the rendered element,
|
|
2965
|
+
* it is also used to specify the active trigger for the popover in controlled mode (with the PopoverRoot `triggerId` prop).
|
|
2966
|
+
*/
|
|
2967
|
+
id?: string | undefined;
|
|
2968
|
+
/**
|
|
2969
|
+
* Whether the popover should also open when the trigger is hovered.
|
|
2970
|
+
* @default false
|
|
2971
|
+
*/
|
|
2972
|
+
openOnHover?: boolean | undefined;
|
|
2973
|
+
/**
|
|
2974
|
+
* How long to wait before the popover may be opened on hover. Specified in milliseconds.
|
|
2975
|
+
*
|
|
2976
|
+
* Requires the `openOnHover` prop.
|
|
2977
|
+
* @default 300
|
|
2978
|
+
*/
|
|
2979
|
+
delay?: number | undefined;
|
|
2980
|
+
/**
|
|
2981
|
+
* How long to wait before closing the popover that was opened on hover.
|
|
2982
|
+
* Specified in milliseconds.
|
|
2983
|
+
*
|
|
2984
|
+
* Requires the `openOnHover` prop.
|
|
2985
|
+
* @default 0
|
|
2986
|
+
*/
|
|
2987
|
+
closeDelay?: number | undefined;
|
|
2988
|
+
};
|
|
2989
|
+
declare namespace PopoverTrigger$1 {
|
|
2990
|
+
type State = PopoverTriggerState;
|
|
2991
|
+
type Props<Payload = unknown> = PopoverTriggerProps<Payload>;
|
|
2992
|
+
}
|
|
2993
|
+
//#endregion
|
|
2994
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/popover/positioner/PopoverPositioner.d.mts
|
|
2995
|
+
/**
|
|
2996
|
+
* Positions the popover against the trigger.
|
|
2997
|
+
* Renders a `<div>` element.
|
|
2998
|
+
*
|
|
2999
|
+
* Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
|
|
3000
|
+
*/
|
|
3001
|
+
declare const PopoverPositioner: React$1.ForwardRefExoticComponent<Omit<PopoverPositionerProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
|
|
3002
|
+
interface PopoverPositionerState {
|
|
3003
|
+
/**
|
|
3004
|
+
* Whether the popover is currently open.
|
|
3005
|
+
*/
|
|
3006
|
+
open: boolean;
|
|
3007
|
+
/**
|
|
3008
|
+
* The side of the anchor the component is placed on.
|
|
3009
|
+
*/
|
|
3010
|
+
side: Side;
|
|
3011
|
+
/**
|
|
3012
|
+
* The alignment of the component relative to the anchor.
|
|
3013
|
+
*/
|
|
3014
|
+
align: Align;
|
|
3015
|
+
/**
|
|
3016
|
+
* Whether the anchor element is hidden.
|
|
3017
|
+
*/
|
|
3018
|
+
anchorHidden: boolean;
|
|
3019
|
+
/**
|
|
3020
|
+
* Whether CSS transitions should be disabled.
|
|
3021
|
+
*/
|
|
3022
|
+
instant: string | undefined;
|
|
3023
|
+
}
|
|
3024
|
+
interface PopoverPositionerProps extends UseAnchorPositioningSharedParameters, BaseUIComponentProps<'div', PopoverPositionerState> {}
|
|
3025
|
+
declare namespace PopoverPositioner {
|
|
3026
|
+
type State = PopoverPositionerState;
|
|
3027
|
+
type Props = PopoverPositionerProps;
|
|
3028
|
+
}
|
|
3029
|
+
//#endregion
|
|
3030
|
+
//#region ../../node_modules/.bun/@base-ui+react@1.9.0+2fba225ddfdb7506/node_modules/@base-ui/react/popover/popup/PopoverPopup.d.mts
|
|
3031
|
+
/**
|
|
3032
|
+
* A container for the popover contents.
|
|
3033
|
+
* Renders a `<div>` element.
|
|
3034
|
+
*
|
|
3035
|
+
* Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
|
|
3036
|
+
*/
|
|
3037
|
+
declare const PopoverPopup: React$1.ForwardRefExoticComponent<Omit<PopoverPopupProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
|
|
3038
|
+
interface PopoverPopupState {
|
|
3039
|
+
/**
|
|
3040
|
+
* Whether the popover is currently open.
|
|
3041
|
+
*/
|
|
3042
|
+
open: boolean;
|
|
3043
|
+
/**
|
|
3044
|
+
* The side of the anchor the component is placed on.
|
|
3045
|
+
*/
|
|
3046
|
+
side: Side;
|
|
3047
|
+
/**
|
|
3048
|
+
* The alignment of the component relative to the anchor.
|
|
3049
|
+
*/
|
|
3050
|
+
align: Align;
|
|
3051
|
+
/**
|
|
3052
|
+
* The transition status of the component.
|
|
3053
|
+
*/
|
|
3054
|
+
transitionStatus: TransitionStatus;
|
|
3055
|
+
/**
|
|
3056
|
+
* Whether transitions should be skipped.
|
|
3057
|
+
*/
|
|
3058
|
+
instant: 'dismiss' | 'click' | 'focus' | 'trigger-change' | undefined;
|
|
3059
|
+
}
|
|
3060
|
+
interface PopoverPopupProps extends BaseUIComponentProps<'div', PopoverPopupState> {
|
|
3061
|
+
/**
|
|
3062
|
+
* Determines the element to focus when the popover is opened.
|
|
3063
|
+
* By default, focus moves to the first tabbable element inside the popup, except when the popover
|
|
3064
|
+
* is opened by touch — then the popup itself is focused to avoid opening the virtual keyboard.
|
|
3065
|
+
*
|
|
3066
|
+
* - `false`: Do not move focus.
|
|
3067
|
+
* - `true`: Move focus based on the default behavior (first tabbable element or popup).
|
|
3068
|
+
* - `RefObject`: Move focus to the ref element.
|
|
3069
|
+
* - `function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`).
|
|
3070
|
+
* Return an element to focus, `true` to use the default behavior, `null` to fall back to the default behavior, or `false`/`undefined` to do nothing.
|
|
3071
|
+
*/
|
|
3072
|
+
initialFocus?: boolean | React$1.RefObject<HTMLElement | null> | ((openType: InteractionType) => void | boolean | HTMLElement | null) | undefined;
|
|
3073
|
+
/**
|
|
3074
|
+
* Determines the element to focus when the popover is closed.
|
|
3075
|
+
*
|
|
3076
|
+
* - `false`: Do not move focus.
|
|
3077
|
+
* - `true`: Move focus based on the default behavior (trigger or previously focused element).
|
|
3078
|
+
* - `RefObject`: Move focus to the ref element.
|
|
3079
|
+
* - `function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`).
|
|
3080
|
+
* Return an element to focus, `true` to use the default behavior, `null` to fall back to the default behavior, or `false`/`undefined` to do nothing.
|
|
3081
|
+
*/
|
|
3082
|
+
finalFocus?: boolean | React$1.RefObject<HTMLElement | null> | ((closeType: InteractionType) => void | boolean | HTMLElement | null) | undefined;
|
|
3083
|
+
}
|
|
3084
|
+
declare namespace PopoverPopup {
|
|
3085
|
+
type State = PopoverPopupState;
|
|
3086
|
+
type Props = PopoverPopupProps;
|
|
3087
|
+
}
|
|
3088
|
+
//#endregion
|
|
3089
|
+
//#region dashboard/components/ui/popover.d.ts
|
|
3090
|
+
declare function Popover({ ...props }: PopoverRoot.Props): import("react").JSX.Element;
|
|
3091
|
+
declare function PopoverTrigger({ ...props }: PopoverTrigger$1.Props): import("react").JSX.Element;
|
|
3092
|
+
declare function PopoverContent({ className, align, alignOffset, side, sideOffset, ...props }: PopoverPopup.Props & Pick<PopoverPositioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): import("react").JSX.Element;
|
|
3093
|
+
//#endregion
|
|
3094
|
+
//#region dashboard/components/ui/separator.d.ts
|
|
3095
|
+
declare function Separator({ className, orientation, ...props }: Separator$1.Props): import("react").JSX.Element;
|
|
3096
|
+
//#endregion
|
|
3097
|
+
//#region dashboard/components/ui/table.d.ts
|
|
3098
|
+
declare function Table({ className, ...props }: React$1.ComponentProps<"table">): React$1.JSX.Element;
|
|
3099
|
+
declare function TableHeader({ className, ...props }: React$1.ComponentProps<"thead">): React$1.JSX.Element;
|
|
3100
|
+
declare function TableBody({ className, ...props }: React$1.ComponentProps<"tbody">): React$1.JSX.Element;
|
|
3101
|
+
declare function TableFooter({ className, ...props }: React$1.ComponentProps<"tfoot">): React$1.JSX.Element;
|
|
3102
|
+
declare function TableRow({ className, ...props }: React$1.ComponentProps<"tr">): React$1.JSX.Element;
|
|
3103
|
+
declare function TableHead({ className, ...props }: React$1.ComponentProps<"th">): React$1.JSX.Element;
|
|
3104
|
+
declare function TableCell({ className, ...props }: React$1.ComponentProps<"td">): React$1.JSX.Element;
|
|
3105
|
+
declare function TableCaption({ className, ...props }: React$1.ComponentProps<"caption">): React$1.JSX.Element;
|
|
3106
|
+
//#endregion
|
|
3107
|
+
//#region dashboard/components/ui/toggle.d.ts
|
|
3108
|
+
declare const toggleVariants: (props?: ({
|
|
3109
|
+
variant?: "default" | "outline" | null | undefined;
|
|
3110
|
+
size?: "default" | "sm" | "lg" | null | undefined;
|
|
3111
|
+
} & import("class-variance-authority/types").ClassProp) | undefined) => string;
|
|
3112
|
+
declare function Toggle({ className, variant, size, ...props }: Toggle$1.Props & VariantProps<typeof toggleVariants>): import("react").JSX.Element;
|
|
3113
|
+
//#endregion
|
|
3114
|
+
//#region dashboard/components/ui/toggle-group.d.ts
|
|
3115
|
+
declare function ToggleGroup({ className, variant, size, spacing, orientation, children, ...props }: ToggleGroup$1.Props & VariantProps<typeof toggleVariants> & {
|
|
3116
|
+
spacing?: number;
|
|
3117
|
+
orientation?: "horizontal" | "vertical";
|
|
3118
|
+
}): React$1.JSX.Element;
|
|
3119
|
+
declare function ToggleGroupItem({ className, children, variant, size, ...props }: Toggle$1.Props & VariantProps<typeof toggleVariants>): React$1.JSX.Element;
|
|
3120
|
+
//#endregion
|
|
3121
|
+
//#region dashboard/components/ui/tooltip.d.ts
|
|
3122
|
+
declare function TooltipProvider({ delay, ...props }: TooltipProvider$1.Props): import("react").JSX.Element;
|
|
3123
|
+
declare function Tooltip({ ...props }: TooltipRoot.Props): import("react").JSX.Element;
|
|
3124
|
+
declare function TooltipTrigger({ ...props }: TooltipTrigger$1.Props): import("react").JSX.Element;
|
|
3125
|
+
declare function TooltipContent({ className, side, sideOffset, align, alignOffset, children, ...props }: TooltipPopup.Props & Pick<TooltipPositioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): import("react").JSX.Element;
|
|
3126
|
+
//#endregion
|
|
3127
|
+
export { type AppFetchResult, Badge, Button, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, type DashboardExtension, type DashboardSlots, type DrawerTab, type DrawerTabContext, type ExtensionPage, Input, Kbd, KbdGroup, type PageProps, type Placement, Popover, PopoverContent, PopoverTrigger, type Route, Separator, type SidebarLink, type SidebarSlotContext, type SlotContext, type SlotName, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TraceSpan, type TraceSummary, badgeVariants, buttonVariants, toggleVariants };
|