nexi-agent 0.1.1 → 0.3.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 +845 -602
- package/dist/{chunk-XDNSQ2Q7.js → chunk-5VCFUEOF.js} +285 -4
- package/dist/chunk-5VCFUEOF.js.map +1 -0
- package/dist/demo.cjs +2265 -17
- package/dist/demo.cjs.map +1 -1
- package/dist/demo.d.cts +1006 -1
- package/dist/demo.d.ts +1006 -1
- package/dist/demo.js +1999 -2
- package/dist/demo.js.map +1 -1
- package/dist/index.cjs +12475 -140
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +2503 -3
- package/dist/index.d.ts +2503 -3
- package/dist/index.js +12051 -127
- package/dist/index.js.map +1 -1
- package/dist/styles.css +1 -1
- package/dist/tailwind.css +824 -0
- package/package.json +3 -3
- package/dist/chunk-XDNSQ2Q7.js.map +0 -1
package/dist/index.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import * as react from 'react';
|
|
2
|
-
import { ButtonHTMLAttributes, ReactNode } from 'react';
|
|
2
|
+
import { ButtonHTMLAttributes, ReactNode, CSSProperties, MouseEvent, ElementType, AnchorHTMLAttributes, InputHTMLAttributes, FormEvent } from 'react';
|
|
3
3
|
import * as class_variance_authority_types from 'class-variance-authority/types';
|
|
4
4
|
import { VariantProps } from 'class-variance-authority';
|
|
5
5
|
export { a as RECORD_TAG_PALETTE, R as RecordRow, b as RecordStrength, c as RecordTagColor, d as RecordsAiColumn, e as RecordsColumnConfig, f as RecordsColumnKey, g as RecordsPrompt, h as RecordsTable, i as RecordsTableLabels, j as RecordsTableProps, k as RecordsToolKind } from './RecordsTable-DHbIfUQH.js';
|
|
@@ -1151,6 +1151,2506 @@ type UsageMeterProps = {
|
|
|
1151
1151
|
};
|
|
1152
1152
|
declare function UsageMeter({ label, used: usedProp, limit, segments, format, warnAt, dangerAt, hint, className, }?: UsageMeterProps): react.JSX.Element;
|
|
1153
1153
|
|
|
1154
|
+
type AnimatedModalLabels = {
|
|
1155
|
+
close: string;
|
|
1156
|
+
};
|
|
1157
|
+
type AnimatedModalProps = {
|
|
1158
|
+
/** Trigger button text. */
|
|
1159
|
+
trigger?: ReactNode;
|
|
1160
|
+
/** Shown in place of the trigger text on hover. */
|
|
1161
|
+
triggerIcon?: ReactNode;
|
|
1162
|
+
title?: ReactNode;
|
|
1163
|
+
children?: ReactNode;
|
|
1164
|
+
/** Footer content; pass a function to get a `close` callback for your buttons. */
|
|
1165
|
+
footer?: ReactNode | ((close: () => void) => ReactNode);
|
|
1166
|
+
/** Controlled open state. */
|
|
1167
|
+
open?: boolean;
|
|
1168
|
+
defaultOpen?: boolean;
|
|
1169
|
+
onOpenChange?: (open: boolean) => void;
|
|
1170
|
+
labels?: Partial<AnimatedModalLabels>;
|
|
1171
|
+
/** Class for the modal panel. */
|
|
1172
|
+
className?: string;
|
|
1173
|
+
};
|
|
1174
|
+
declare function AnimatedModal({ trigger, triggerIcon, title, children, footer, open: controlled, defaultOpen, onOpenChange, labels, className, }: AnimatedModalProps): react.JSX.Element;
|
|
1175
|
+
|
|
1176
|
+
type AnimatedTab = {
|
|
1177
|
+
title: string;
|
|
1178
|
+
value: string;
|
|
1179
|
+
content?: ReactNode;
|
|
1180
|
+
};
|
|
1181
|
+
type AnimatedTabsProps = {
|
|
1182
|
+
tabs?: AnimatedTab[];
|
|
1183
|
+
defaultValue?: string;
|
|
1184
|
+
onValueChange?: (value: string) => void;
|
|
1185
|
+
className?: string;
|
|
1186
|
+
/** Height of the panel stack (px). */
|
|
1187
|
+
panelHeight?: number;
|
|
1188
|
+
};
|
|
1189
|
+
declare function AnimatedTabs({ tabs, defaultValue, onValueChange, className, panelHeight, }: AnimatedTabsProps): react.JSX.Element;
|
|
1190
|
+
|
|
1191
|
+
type Testimonial = {
|
|
1192
|
+
quote: string;
|
|
1193
|
+
name: string;
|
|
1194
|
+
designation?: string;
|
|
1195
|
+
/** Photo URL; falls back to a coloured monogram tile. */
|
|
1196
|
+
src?: string;
|
|
1197
|
+
color?: string;
|
|
1198
|
+
};
|
|
1199
|
+
type AnimatedTestimonialsLabels = {
|
|
1200
|
+
previous: string;
|
|
1201
|
+
next: string;
|
|
1202
|
+
};
|
|
1203
|
+
type AnimatedTestimonialsProps = {
|
|
1204
|
+
items?: Testimonial[];
|
|
1205
|
+
autoplay?: boolean;
|
|
1206
|
+
/** Milliseconds per testimonial when autoplaying. */
|
|
1207
|
+
interval?: number;
|
|
1208
|
+
labels?: Partial<AnimatedTestimonialsLabels>;
|
|
1209
|
+
className?: string;
|
|
1210
|
+
};
|
|
1211
|
+
declare function AnimatedTestimonials({ items, autoplay, interval, labels, className, }: AnimatedTestimonialsProps): react.JSX.Element;
|
|
1212
|
+
|
|
1213
|
+
type TooltipPerson = {
|
|
1214
|
+
id: string | number;
|
|
1215
|
+
name: string;
|
|
1216
|
+
designation?: string;
|
|
1217
|
+
/** Image URL; falls back to a coloured monogram. */
|
|
1218
|
+
image?: string;
|
|
1219
|
+
color?: string;
|
|
1220
|
+
};
|
|
1221
|
+
type AnimatedTooltipProps = {
|
|
1222
|
+
items?: TooltipPerson[];
|
|
1223
|
+
/** Avatar diameter in px. */
|
|
1224
|
+
size?: number;
|
|
1225
|
+
className?: string;
|
|
1226
|
+
};
|
|
1227
|
+
declare function AnimatedTooltip({ items, size, className }: AnimatedTooltipProps): react.JSX.Element;
|
|
1228
|
+
|
|
1229
|
+
type GlobeArc = {
|
|
1230
|
+
from: {
|
|
1231
|
+
lat: number;
|
|
1232
|
+
lng: number;
|
|
1233
|
+
};
|
|
1234
|
+
to: {
|
|
1235
|
+
lat: number;
|
|
1236
|
+
lng: number;
|
|
1237
|
+
};
|
|
1238
|
+
color?: string;
|
|
1239
|
+
};
|
|
1240
|
+
type ArcGlobeProps = {
|
|
1241
|
+
arcs?: GlobeArc[];
|
|
1242
|
+
/** Colours used for arcs without their own. */
|
|
1243
|
+
arcColors?: string[];
|
|
1244
|
+
dotColor?: string;
|
|
1245
|
+
/** Fill of the globe body. */
|
|
1246
|
+
oceanColor?: string;
|
|
1247
|
+
atmosphereColor?: string;
|
|
1248
|
+
/** How high arcs rise off the surface, 0–1. */
|
|
1249
|
+
arcHeight?: number;
|
|
1250
|
+
/** Seconds for one arc flight. */
|
|
1251
|
+
flightTime?: number;
|
|
1252
|
+
density?: number;
|
|
1253
|
+
autoRotate?: number;
|
|
1254
|
+
draggable?: boolean;
|
|
1255
|
+
focus?: {
|
|
1256
|
+
lat: number;
|
|
1257
|
+
lng: number;
|
|
1258
|
+
};
|
|
1259
|
+
size?: number;
|
|
1260
|
+
label?: string;
|
|
1261
|
+
className?: string;
|
|
1262
|
+
};
|
|
1263
|
+
declare function ArcGlobe({ arcs, arcColors, dotColor, oceanColor, atmosphereColor, arcHeight, flightTime, density, autoRotate, draggable, focus, size, label, className, }: ArcGlobeProps): react.JSX.Element;
|
|
1264
|
+
|
|
1265
|
+
type AsciiArtProps = {
|
|
1266
|
+
src?: string;
|
|
1267
|
+
/** Characters per row. */
|
|
1268
|
+
columns?: number;
|
|
1269
|
+
/** Characters from lightest to densest. */
|
|
1270
|
+
ramp?: string;
|
|
1271
|
+
/** Flip the ramp, for light text on a dark background. */
|
|
1272
|
+
invert?: boolean;
|
|
1273
|
+
/** Use the image's colours for each character. */
|
|
1274
|
+
colored?: boolean;
|
|
1275
|
+
/** Reveal the art row by row. */
|
|
1276
|
+
animate?: boolean;
|
|
1277
|
+
className?: string;
|
|
1278
|
+
};
|
|
1279
|
+
declare function AsciiArt({ src, columns, ramp, invert, colored, animate, className, }: AsciiArtProps): react.JSX.Element;
|
|
1280
|
+
|
|
1281
|
+
type AuroraBackgroundProps = {
|
|
1282
|
+
children?: ReactNode;
|
|
1283
|
+
/** Fade the aurora out away from the top-right so it reads as a light source. */
|
|
1284
|
+
showRadialGradient?: boolean;
|
|
1285
|
+
className?: string;
|
|
1286
|
+
};
|
|
1287
|
+
declare function AuroraBackground({ children, showRadialGradient, className }: AuroraBackgroundProps): react.JSX.Element;
|
|
1288
|
+
|
|
1289
|
+
type BackgroundBeamsProps = {
|
|
1290
|
+
children?: ReactNode;
|
|
1291
|
+
/** How many beams in the fan. */
|
|
1292
|
+
count?: number;
|
|
1293
|
+
className?: string;
|
|
1294
|
+
};
|
|
1295
|
+
declare function BackgroundBeams({ children, count, className }: BackgroundBeamsProps): react.JSX.Element;
|
|
1296
|
+
|
|
1297
|
+
type BackgroundBoxesProps = {
|
|
1298
|
+
children?: ReactNode;
|
|
1299
|
+
rows?: number;
|
|
1300
|
+
cols?: number;
|
|
1301
|
+
/** Tile size in px. */
|
|
1302
|
+
cellSize?: number;
|
|
1303
|
+
/** Tiles pick one of these at random when lit. */
|
|
1304
|
+
colors?: string[];
|
|
1305
|
+
/** Milliseconds a lit tile takes to fade out. */
|
|
1306
|
+
fadeMs?: number;
|
|
1307
|
+
className?: string;
|
|
1308
|
+
};
|
|
1309
|
+
declare function BackgroundBoxes({ children, rows, cols, cellSize, colors, fadeMs, className, }: BackgroundBoxesProps): react.JSX.Element;
|
|
1310
|
+
|
|
1311
|
+
type BackgroundCubesGridProps = {
|
|
1312
|
+
children?: ReactNode;
|
|
1313
|
+
rows?: number;
|
|
1314
|
+
cols?: number;
|
|
1315
|
+
/** Cube edge in px. */
|
|
1316
|
+
cellSize?: number;
|
|
1317
|
+
/** How high (px) the cube under the pointer rises. */
|
|
1318
|
+
lift?: number;
|
|
1319
|
+
/** How many cubes away the rise reaches. */
|
|
1320
|
+
reach?: number;
|
|
1321
|
+
/** Top-face colour of a raised cube. */
|
|
1322
|
+
color?: string;
|
|
1323
|
+
className?: string;
|
|
1324
|
+
};
|
|
1325
|
+
declare function BackgroundCubesGrid({ children, rows, cols, cellSize, lift, reach, color, className, }: BackgroundCubesGridProps): react.JSX.Element;
|
|
1326
|
+
|
|
1327
|
+
type BackgroundGradientProps = {
|
|
1328
|
+
children?: ReactNode;
|
|
1329
|
+
/** Colours around the frame, in order. */
|
|
1330
|
+
colors?: string[];
|
|
1331
|
+
/** Turn the colours around the frame. */
|
|
1332
|
+
animate?: boolean;
|
|
1333
|
+
/** Seconds for one full turn. */
|
|
1334
|
+
duration?: number;
|
|
1335
|
+
/** Frame thickness in px. */
|
|
1336
|
+
borderWidth?: number;
|
|
1337
|
+
/** Outer radius in px. */
|
|
1338
|
+
radius?: number;
|
|
1339
|
+
/** Class for the outer frame. */
|
|
1340
|
+
containerClassName?: string;
|
|
1341
|
+
/** Class for the inner face. */
|
|
1342
|
+
className?: string;
|
|
1343
|
+
};
|
|
1344
|
+
declare function BackgroundGradient({ children, colors, animate, duration, borderWidth, radius, containerClassName, className, }: BackgroundGradientProps): react.JSX.Element;
|
|
1345
|
+
|
|
1346
|
+
type GradientOrb = {
|
|
1347
|
+
/** Any CSS colour. */
|
|
1348
|
+
color: string;
|
|
1349
|
+
/** Resting position, in % of the container. */
|
|
1350
|
+
x: number;
|
|
1351
|
+
y: number;
|
|
1352
|
+
/** How far it drifts, in % of its own size. */
|
|
1353
|
+
drift?: number;
|
|
1354
|
+
/** Seconds per drift loop. */
|
|
1355
|
+
duration?: number;
|
|
1356
|
+
};
|
|
1357
|
+
type BackgroundGradientAnimationProps = {
|
|
1358
|
+
children?: ReactNode;
|
|
1359
|
+
/** Field gradient colours. */
|
|
1360
|
+
from?: string;
|
|
1361
|
+
to?: string;
|
|
1362
|
+
orbs?: GradientOrb[];
|
|
1363
|
+
/** Colour of the orb that follows the pointer. */
|
|
1364
|
+
pointerColor?: string;
|
|
1365
|
+
/** Orb diameter, any CSS length. */
|
|
1366
|
+
size?: string;
|
|
1367
|
+
/** How the orbs mix with each other. */
|
|
1368
|
+
blendMode?: CSSProperties["mixBlendMode"];
|
|
1369
|
+
/** Let an orb follow the pointer. */
|
|
1370
|
+
interactive?: boolean;
|
|
1371
|
+
className?: string;
|
|
1372
|
+
};
|
|
1373
|
+
declare function BackgroundGradientAnimation({ children, from, to, orbs, pointerColor, size, blendMode, interactive, className, }: BackgroundGradientAnimationProps): react.JSX.Element;
|
|
1374
|
+
|
|
1375
|
+
type BackgroundLinesProps = {
|
|
1376
|
+
children?: ReactNode;
|
|
1377
|
+
/** Number of curves. */
|
|
1378
|
+
count?: number;
|
|
1379
|
+
/** Colours the curves cycle through. */
|
|
1380
|
+
colors?: string[];
|
|
1381
|
+
/** Base seconds for one stroke to travel a curve. */
|
|
1382
|
+
duration?: number;
|
|
1383
|
+
className?: string;
|
|
1384
|
+
};
|
|
1385
|
+
declare function BackgroundLines({ children, count, colors, duration, className, }: BackgroundLinesProps): react.JSX.Element;
|
|
1386
|
+
|
|
1387
|
+
type BackgroundRippleEffectProps = {
|
|
1388
|
+
children?: ReactNode;
|
|
1389
|
+
rows?: number;
|
|
1390
|
+
cols?: number;
|
|
1391
|
+
/** Tile size in px. */
|
|
1392
|
+
cellSize?: number;
|
|
1393
|
+
/** Milliseconds for the ring to travel one tile. */
|
|
1394
|
+
stepMs?: number;
|
|
1395
|
+
/** fired with the clicked tile */
|
|
1396
|
+
onCellClick?: (row: number, col: number) => void;
|
|
1397
|
+
className?: string;
|
|
1398
|
+
};
|
|
1399
|
+
declare function BackgroundRippleEffect({ children, rows, cols, cellSize, stepMs, onCellClick, className, }: BackgroundRippleEffectProps): react.JSX.Element;
|
|
1400
|
+
|
|
1401
|
+
type FallingBeam = {
|
|
1402
|
+
/** Horizontal position, % of the width. */
|
|
1403
|
+
x: number;
|
|
1404
|
+
/** Seconds to fall the full height. */
|
|
1405
|
+
duration: number;
|
|
1406
|
+
/** Seconds before the first fall. */
|
|
1407
|
+
delay?: number;
|
|
1408
|
+
/** Beam length in px. */
|
|
1409
|
+
length?: number;
|
|
1410
|
+
};
|
|
1411
|
+
type BeamsWithCollisionProps = {
|
|
1412
|
+
children?: ReactNode;
|
|
1413
|
+
/** Explicit beams; otherwise `count` beams are placed for you. */
|
|
1414
|
+
beams?: FallingBeam[];
|
|
1415
|
+
count?: number;
|
|
1416
|
+
/** Colours of the beam head and the sparks. */
|
|
1417
|
+
color?: string;
|
|
1418
|
+
accentColor?: string;
|
|
1419
|
+
className?: string;
|
|
1420
|
+
};
|
|
1421
|
+
declare function BeamsWithCollision({ children, beams, count, color, accentColor, className, }: BeamsWithCollisionProps): react.JSX.Element;
|
|
1422
|
+
|
|
1423
|
+
type BentoGridProps = {
|
|
1424
|
+
/** Tiles to render; ignored when you pass children. */
|
|
1425
|
+
items?: BentoGridItemProps[];
|
|
1426
|
+
children?: ReactNode;
|
|
1427
|
+
className?: string;
|
|
1428
|
+
};
|
|
1429
|
+
type BentoGridItemProps = {
|
|
1430
|
+
title?: ReactNode;
|
|
1431
|
+
description?: ReactNode;
|
|
1432
|
+
header?: ReactNode;
|
|
1433
|
+
icon?: ReactNode;
|
|
1434
|
+
className?: string;
|
|
1435
|
+
};
|
|
1436
|
+
declare function BentoGridItem({ title, description, header, icon, className }: BentoGridItemProps): react.JSX.Element;
|
|
1437
|
+
declare function BentoGrid({ items, children, className }: BentoGridProps): react.JSX.Element;
|
|
1438
|
+
|
|
1439
|
+
type BlendCursorProps = {
|
|
1440
|
+
children?: ReactNode;
|
|
1441
|
+
/** Diameter at rest and over interactive elements, in px. */
|
|
1442
|
+
size?: number;
|
|
1443
|
+
hoverSize?: number;
|
|
1444
|
+
/** Which elements make it grow. */
|
|
1445
|
+
selector?: string;
|
|
1446
|
+
/** Circle colour; white gives a true colour inversion. */
|
|
1447
|
+
color?: string;
|
|
1448
|
+
className?: string;
|
|
1449
|
+
};
|
|
1450
|
+
declare function BlendCursor({ children, size, hoverSize, selector, color, className, }: BlendCursorProps): react.JSX.Element;
|
|
1451
|
+
|
|
1452
|
+
type BurstIconShape = "heart" | "star" | "bookmark" | "thumb";
|
|
1453
|
+
type BurstIconProps = {
|
|
1454
|
+
/** Built-in shape, used when no children are given. */
|
|
1455
|
+
icon?: BurstIconShape;
|
|
1456
|
+
/** Your own icon; it should use currentColor. */
|
|
1457
|
+
children?: ReactNode;
|
|
1458
|
+
/** Controlled state. */
|
|
1459
|
+
pressed?: boolean;
|
|
1460
|
+
defaultPressed?: boolean;
|
|
1461
|
+
onChange?: (pressed: boolean) => void;
|
|
1462
|
+
/** Colour when on. */
|
|
1463
|
+
color?: string;
|
|
1464
|
+
/** Accessible name, e.g. "Like". */
|
|
1465
|
+
label?: string;
|
|
1466
|
+
/** Icon size in px. */
|
|
1467
|
+
size?: number;
|
|
1468
|
+
/** Optional count shown beside the icon. */
|
|
1469
|
+
count?: number;
|
|
1470
|
+
className?: string;
|
|
1471
|
+
};
|
|
1472
|
+
declare function BurstIcon({ icon, children, pressed, defaultPressed, onChange, color, label, size, count, className, }: BurstIconProps): react.JSX.Element;
|
|
1473
|
+
|
|
1474
|
+
type CanvasRevealEffectProps = {
|
|
1475
|
+
children?: ReactNode;
|
|
1476
|
+
/** Dot colours, any CSS colour. */
|
|
1477
|
+
colors?: string[];
|
|
1478
|
+
/** Dot size and spacing in px. */
|
|
1479
|
+
dotSize?: number;
|
|
1480
|
+
gap?: number;
|
|
1481
|
+
/** Milliseconds per px for the reveal wave to spread. */
|
|
1482
|
+
speed?: number;
|
|
1483
|
+
/** Background behind the dots while revealed. */
|
|
1484
|
+
revealBackground?: string;
|
|
1485
|
+
/** Force the reveal on (otherwise it follows hover). */
|
|
1486
|
+
active?: boolean;
|
|
1487
|
+
className?: string;
|
|
1488
|
+
};
|
|
1489
|
+
declare function CanvasRevealEffect({ children, colors, dotSize, gap, speed, revealBackground, active, className, }: CanvasRevealEffectProps): react.JSX.Element;
|
|
1490
|
+
|
|
1491
|
+
type CanvasTextProps = {
|
|
1492
|
+
text?: string;
|
|
1493
|
+
/** Colours of the flowing bands. */
|
|
1494
|
+
colors?: string[];
|
|
1495
|
+
/** Any CSS font weight and family for the lettering. */
|
|
1496
|
+
font?: string;
|
|
1497
|
+
/** Height of the canvas in px; the text is sized to fit it. */
|
|
1498
|
+
height?: number;
|
|
1499
|
+
/** Flow speed multiplier. */
|
|
1500
|
+
speed?: number;
|
|
1501
|
+
className?: string;
|
|
1502
|
+
};
|
|
1503
|
+
declare function CanvasText({ text, colors, font, height, speed, className, }: CanvasTextProps): react.JSX.Element;
|
|
1504
|
+
|
|
1505
|
+
declare const CAPTION_HOVER_VARIANTS: readonly ["slide", "reveal", "frame", "split", "zoom", "lift", "corner", "blinds"];
|
|
1506
|
+
type CaptionHoverVariant = (typeof CAPTION_HOVER_VARIANTS)[number];
|
|
1507
|
+
type CaptionHoverProps = {
|
|
1508
|
+
image?: string;
|
|
1509
|
+
title?: ReactNode;
|
|
1510
|
+
description?: ReactNode;
|
|
1511
|
+
variant?: CaptionHoverVariant;
|
|
1512
|
+
/** Make the card a link. */
|
|
1513
|
+
href?: string;
|
|
1514
|
+
onClick?: (event: MouseEvent<HTMLElement>) => void;
|
|
1515
|
+
aspectRatio?: string;
|
|
1516
|
+
className?: string;
|
|
1517
|
+
};
|
|
1518
|
+
declare function CaptionHover({ image, title, description, variant: v, href, onClick, aspectRatio, className, }: CaptionHoverProps): react.JSX.Element;
|
|
1519
|
+
|
|
1520
|
+
type Card3DProps = {
|
|
1521
|
+
children?: ReactNode;
|
|
1522
|
+
/** Maximum turn in degrees. */
|
|
1523
|
+
maxTilt?: number;
|
|
1524
|
+
/** Class for the outer element that holds the perspective. */
|
|
1525
|
+
containerClassName?: string;
|
|
1526
|
+
className?: string;
|
|
1527
|
+
};
|
|
1528
|
+
declare function Card3D({ children, maxTilt, containerClassName, className }: Card3DProps): react.JSX.Element;
|
|
1529
|
+
type Card3DItemProps = {
|
|
1530
|
+
children?: ReactNode;
|
|
1531
|
+
/** Element to render. */
|
|
1532
|
+
as?: ElementType;
|
|
1533
|
+
/** How far (px) the item lifts toward the viewer on hover. */
|
|
1534
|
+
translateZ?: number;
|
|
1535
|
+
translateX?: number;
|
|
1536
|
+
translateY?: number;
|
|
1537
|
+
rotateX?: number;
|
|
1538
|
+
rotateY?: number;
|
|
1539
|
+
rotateZ?: number;
|
|
1540
|
+
className?: string;
|
|
1541
|
+
style?: CSSProperties;
|
|
1542
|
+
};
|
|
1543
|
+
declare function Card3DItem({ children, as: Tag, translateZ, translateX, translateY, rotateX, rotateY, rotateZ, className, style, }: Card3DItemProps): react.JSX.Element;
|
|
1544
|
+
|
|
1545
|
+
type HoverCardItem = {
|
|
1546
|
+
title: string;
|
|
1547
|
+
description: string;
|
|
1548
|
+
href?: string;
|
|
1549
|
+
};
|
|
1550
|
+
type CardHoverEffectProps = {
|
|
1551
|
+
items?: HoverCardItem[];
|
|
1552
|
+
/** fired when a card without an href is clicked */
|
|
1553
|
+
onSelect?: (item: HoverCardItem, index: number) => void;
|
|
1554
|
+
className?: string;
|
|
1555
|
+
};
|
|
1556
|
+
declare function CardHoverEffect({ items, onSelect, className }: CardHoverEffectProps): react.JSX.Element;
|
|
1557
|
+
|
|
1558
|
+
type StackCard = {
|
|
1559
|
+
id: string | number;
|
|
1560
|
+
name: string;
|
|
1561
|
+
designation?: string;
|
|
1562
|
+
content: ReactNode;
|
|
1563
|
+
};
|
|
1564
|
+
type CardStackProps = {
|
|
1565
|
+
items?: StackCard[];
|
|
1566
|
+
/** Vertical offset between stacked cards, px. */
|
|
1567
|
+
offset?: number;
|
|
1568
|
+
/** How much smaller each card behind is, 0–1. */
|
|
1569
|
+
scaleFactor?: number;
|
|
1570
|
+
/** Milliseconds between automatic shuffles; 0 turns it off. */
|
|
1571
|
+
interval?: number;
|
|
1572
|
+
className?: string;
|
|
1573
|
+
};
|
|
1574
|
+
declare function CardStack({ items, offset, scaleFactor, interval, className, }: CardStackProps): react.JSX.Element;
|
|
1575
|
+
|
|
1576
|
+
type CarouselCard = {
|
|
1577
|
+
category: string;
|
|
1578
|
+
title: string;
|
|
1579
|
+
/** Cover image URL. */
|
|
1580
|
+
image?: string;
|
|
1581
|
+
/** CSS background used when there's no image (a colour or gradient). */
|
|
1582
|
+
background?: string;
|
|
1583
|
+
/** Shown when the card is opened. */
|
|
1584
|
+
content?: ReactNode;
|
|
1585
|
+
};
|
|
1586
|
+
type CardsCarouselLabels = {
|
|
1587
|
+
previous: string;
|
|
1588
|
+
next: string;
|
|
1589
|
+
close: string;
|
|
1590
|
+
};
|
|
1591
|
+
type CardsCarouselProps = {
|
|
1592
|
+
items?: CarouselCard[];
|
|
1593
|
+
labels?: Partial<CardsCarouselLabels>;
|
|
1594
|
+
/** fired when a card is opened */
|
|
1595
|
+
onOpen?: (card: CarouselCard, index: number) => void;
|
|
1596
|
+
className?: string;
|
|
1597
|
+
};
|
|
1598
|
+
declare function CardsCarousel({ items, labels, onOpen, className }: CardsCarouselProps): react.JSX.Element;
|
|
1599
|
+
|
|
1600
|
+
type Carousel3DSlide = {
|
|
1601
|
+
src: string;
|
|
1602
|
+
title: string;
|
|
1603
|
+
/** Text of the button on the current slide. Leave out for no button. */
|
|
1604
|
+
action?: string;
|
|
1605
|
+
};
|
|
1606
|
+
type Carousel3DLabels = {
|
|
1607
|
+
previous: string;
|
|
1608
|
+
next: string;
|
|
1609
|
+
region: string;
|
|
1610
|
+
};
|
|
1611
|
+
type Carousel3DProps = {
|
|
1612
|
+
slides?: Carousel3DSlide[];
|
|
1613
|
+
/** Fired by the button on the current slide. */
|
|
1614
|
+
onAction?: (slide: Carousel3DSlide, index: number) => void;
|
|
1615
|
+
onIndexChange?: (index: number) => void;
|
|
1616
|
+
/** Slide width in px (shrinks to fit narrow screens). */
|
|
1617
|
+
slideWidth?: number;
|
|
1618
|
+
labels?: Partial<Carousel3DLabels>;
|
|
1619
|
+
className?: string;
|
|
1620
|
+
};
|
|
1621
|
+
declare function Carousel3D({ slides, onAction, onIndexChange, slideWidth, labels, className, }: Carousel3DProps): react.JSX.Element;
|
|
1622
|
+
|
|
1623
|
+
type ChromaticImageProps = {
|
|
1624
|
+
src?: string;
|
|
1625
|
+
alt?: string;
|
|
1626
|
+
/** Maximum channel split in px. */
|
|
1627
|
+
intensity?: number;
|
|
1628
|
+
/** Keep a small split even when the pointer is away. */
|
|
1629
|
+
idleSplit?: number;
|
|
1630
|
+
/** Corner radius in px. */
|
|
1631
|
+
radius?: number;
|
|
1632
|
+
className?: string;
|
|
1633
|
+
};
|
|
1634
|
+
declare function ChromaticImage({ src, alt, intensity, idleSplit, radius, className, }: ChromaticImageProps): react.JSX.Element;
|
|
1635
|
+
|
|
1636
|
+
type CipherCardProps = {
|
|
1637
|
+
/** Shown in the middle of the card. */
|
|
1638
|
+
children?: ReactNode;
|
|
1639
|
+
/** Characters the wall is made of. */
|
|
1640
|
+
charset?: string;
|
|
1641
|
+
/** Glow gradient colours. */
|
|
1642
|
+
colors?: [string, string];
|
|
1643
|
+
/** Glow radius in px. */
|
|
1644
|
+
radius?: number;
|
|
1645
|
+
className?: string;
|
|
1646
|
+
};
|
|
1647
|
+
declare function CipherCard({ children, charset, colors, radius, className, }: CipherCardProps): react.JSX.Element;
|
|
1648
|
+
|
|
1649
|
+
type CircularTextProps = {
|
|
1650
|
+
text?: string;
|
|
1651
|
+
/** Diameter in px. */
|
|
1652
|
+
size?: number;
|
|
1653
|
+
/** Seconds per turn at rest. 0 stops it. */
|
|
1654
|
+
duration?: number;
|
|
1655
|
+
/** What hovering does to the spin. */
|
|
1656
|
+
onHover?: "speedUp" | "pause" | "reverse" | "none";
|
|
1657
|
+
/** Anything in the middle, e.g. an arrow icon. */
|
|
1658
|
+
children?: ReactNode;
|
|
1659
|
+
className?: string;
|
|
1660
|
+
};
|
|
1661
|
+
declare function CircularText({ text, size, duration, onHover, children, className, }: CircularTextProps): react.JSX.Element;
|
|
1662
|
+
|
|
1663
|
+
type CloudShaderProps = {
|
|
1664
|
+
children?: ReactNode;
|
|
1665
|
+
/** Sky gradient, top to bottom. */
|
|
1666
|
+
skyTop?: string;
|
|
1667
|
+
skyBottom?: string;
|
|
1668
|
+
/** Cloud colour as [r, g, b]. */
|
|
1669
|
+
cloudColor?: [number, number, number];
|
|
1670
|
+
/** 0–1: how much of the sky is covered. */
|
|
1671
|
+
coverage?: number;
|
|
1672
|
+
/** Drift speed multiplier. */
|
|
1673
|
+
speed?: number;
|
|
1674
|
+
/** Noise resolution divisor; higher is cheaper and softer. */
|
|
1675
|
+
resolution?: number;
|
|
1676
|
+
className?: string;
|
|
1677
|
+
};
|
|
1678
|
+
declare function CloudShader({ children, skyTop, skyBottom, cloudColor, coverage, speed, resolution, className, }: CloudShaderProps): react.JSX.Element;
|
|
1679
|
+
|
|
1680
|
+
type ColourfulTextProps = {
|
|
1681
|
+
text?: string;
|
|
1682
|
+
colors?: string[];
|
|
1683
|
+
/** Milliseconds between reshuffles. */
|
|
1684
|
+
interval?: number;
|
|
1685
|
+
className?: string;
|
|
1686
|
+
};
|
|
1687
|
+
declare function ColourfulText({ text, colors, interval, className }: ColourfulTextProps): react.JSX.Element;
|
|
1688
|
+
|
|
1689
|
+
type CometCardProps = {
|
|
1690
|
+
children?: ReactNode;
|
|
1691
|
+
/** Maximum tilt in degrees. */
|
|
1692
|
+
maxTilt?: number;
|
|
1693
|
+
/** How far (px) the card lifts toward the viewer on hover. */
|
|
1694
|
+
lift?: number;
|
|
1695
|
+
/** Corner radius in px. */
|
|
1696
|
+
radius?: number;
|
|
1697
|
+
className?: string;
|
|
1698
|
+
};
|
|
1699
|
+
declare function CometCard({ children, maxTilt, lift, radius, className }: CometCardProps): react.JSX.Element;
|
|
1700
|
+
|
|
1701
|
+
type CompareLabels = {
|
|
1702
|
+
before: string;
|
|
1703
|
+
after: string;
|
|
1704
|
+
handle: string;
|
|
1705
|
+
};
|
|
1706
|
+
type CompareProps = {
|
|
1707
|
+
/** Image on the left of the divider. */
|
|
1708
|
+
before?: string;
|
|
1709
|
+
/** Image on the right of the divider. */
|
|
1710
|
+
after?: string;
|
|
1711
|
+
/** Drag the handle, or follow the pointer on hover. */
|
|
1712
|
+
mode?: "drag" | "hover";
|
|
1713
|
+
/** Start position, 0–100. */
|
|
1714
|
+
initial?: number;
|
|
1715
|
+
/** Sweep back and forth until touched. */
|
|
1716
|
+
autoplay?: boolean;
|
|
1717
|
+
/** Show the before / after tags. */
|
|
1718
|
+
showLabels?: boolean;
|
|
1719
|
+
onChange?: (position: number) => void;
|
|
1720
|
+
aspectRatio?: string;
|
|
1721
|
+
labels?: Partial<CompareLabels>;
|
|
1722
|
+
className?: string;
|
|
1723
|
+
};
|
|
1724
|
+
declare function Compare({ before, after, mode, initial, autoplay, showLabels, onChange, aspectRatio, labels, className, }: CompareProps): react.JSX.Element;
|
|
1725
|
+
|
|
1726
|
+
type ContainerCoverProps = {
|
|
1727
|
+
children?: ReactNode;
|
|
1728
|
+
/** Colours of the light streaks. */
|
|
1729
|
+
colors?: string[];
|
|
1730
|
+
/** Number of streaks. */
|
|
1731
|
+
streaks?: number;
|
|
1732
|
+
className?: string;
|
|
1733
|
+
};
|
|
1734
|
+
declare function ContainerCover({ children, colors, streaks, className }: ContainerCoverProps): react.JSX.Element;
|
|
1735
|
+
|
|
1736
|
+
type ContainerScrollAnimationProps = {
|
|
1737
|
+
/** Heading above the frame. */
|
|
1738
|
+
title?: ReactNode;
|
|
1739
|
+
/** Shown inside the frame. */
|
|
1740
|
+
children?: ReactNode;
|
|
1741
|
+
/** Starting tilt in degrees. */
|
|
1742
|
+
tilt?: number;
|
|
1743
|
+
className?: string;
|
|
1744
|
+
};
|
|
1745
|
+
declare function ContainerScrollAnimation({ title, children, tilt, className }: ContainerScrollAnimationProps): react.JSX.Element;
|
|
1746
|
+
|
|
1747
|
+
type ContainerTextFlipProps = {
|
|
1748
|
+
words?: string[];
|
|
1749
|
+
/** Milliseconds each word stays. */
|
|
1750
|
+
interval?: number;
|
|
1751
|
+
/** Class for the box. */
|
|
1752
|
+
className?: string;
|
|
1753
|
+
/** Class for the word. */
|
|
1754
|
+
textClassName?: string;
|
|
1755
|
+
};
|
|
1756
|
+
declare function ContainerTextFlip({ words, interval, className, textClassName }: ContainerTextFlipProps): react.JSX.Element;
|
|
1757
|
+
|
|
1758
|
+
type CountUpProps = {
|
|
1759
|
+
/** The final number. */
|
|
1760
|
+
value?: number;
|
|
1761
|
+
/** Where counting starts. */
|
|
1762
|
+
from?: number;
|
|
1763
|
+
/** Length in ms. */
|
|
1764
|
+
duration?: number;
|
|
1765
|
+
decimals?: number;
|
|
1766
|
+
prefix?: string;
|
|
1767
|
+
suffix?: string;
|
|
1768
|
+
/** Locale for formatting, e.g. "en-IN"; defaults to the reader's. */
|
|
1769
|
+
locale?: string;
|
|
1770
|
+
/** Show compact figures like 12.5K. */
|
|
1771
|
+
compact?: boolean;
|
|
1772
|
+
className?: string;
|
|
1773
|
+
};
|
|
1774
|
+
declare function CountUp({ value, from, duration, decimals, prefix, suffix, locale, compact, className, }: CountUpProps): react.JSX.Element;
|
|
1775
|
+
|
|
1776
|
+
type DirectionAwareHoverProps = {
|
|
1777
|
+
src?: string;
|
|
1778
|
+
alt?: string;
|
|
1779
|
+
/** Caption shown over the picture on hover. */
|
|
1780
|
+
children?: ReactNode;
|
|
1781
|
+
/** Class for the outer card. */
|
|
1782
|
+
className?: string;
|
|
1783
|
+
/** Class for the caption. */
|
|
1784
|
+
childrenClassName?: string;
|
|
1785
|
+
};
|
|
1786
|
+
declare function DirectionAwareHover({ src, alt, children, className, childrenClassName }: DirectionAwareHoverProps): react.JSX.Element;
|
|
1787
|
+
|
|
1788
|
+
type DitherShaderProps = {
|
|
1789
|
+
/** Image to dither. Leave out for an animated plasma field. Must be same-origin or CORS-enabled. */
|
|
1790
|
+
src?: string;
|
|
1791
|
+
/** Palette from darkest to lightest; two colours give classic 1-bit dithering. */
|
|
1792
|
+
colors?: string[];
|
|
1793
|
+
/** Size of one dither pixel in CSS px. */
|
|
1794
|
+
pixelSize?: number;
|
|
1795
|
+
/** Animation speed multiplier. */
|
|
1796
|
+
speed?: number;
|
|
1797
|
+
/** Strength of the moving ripple of light, 0–1. */
|
|
1798
|
+
ripple?: number;
|
|
1799
|
+
/** Brightness contrast, 1 is neutral. */
|
|
1800
|
+
contrast?: number;
|
|
1801
|
+
/** Height of the canvas in px. */
|
|
1802
|
+
height?: number;
|
|
1803
|
+
/** Accessible description. */
|
|
1804
|
+
label?: string;
|
|
1805
|
+
className?: string;
|
|
1806
|
+
};
|
|
1807
|
+
declare function DitherShader({ src, colors, pixelSize, speed, ripple, contrast, height, label, className, }: DitherShaderProps): react.JSX.Element;
|
|
1808
|
+
|
|
1809
|
+
type DottedGlowBackgroundProps = {
|
|
1810
|
+
children?: ReactNode;
|
|
1811
|
+
/** Distance between dots in px. */
|
|
1812
|
+
gap?: number;
|
|
1813
|
+
/** Dot radius in px. */
|
|
1814
|
+
radius?: number;
|
|
1815
|
+
/** Share of dots that glow, 0–1. */
|
|
1816
|
+
glowRatio?: number;
|
|
1817
|
+
/** Dot colour. Defaults to the muted ink token. */
|
|
1818
|
+
color?: string;
|
|
1819
|
+
/** Glow colour. Defaults to the accent token. */
|
|
1820
|
+
glowColor?: string;
|
|
1821
|
+
/** Multiplier for how fast dots breathe. */
|
|
1822
|
+
speed?: number;
|
|
1823
|
+
className?: string;
|
|
1824
|
+
};
|
|
1825
|
+
declare function DottedGlowBackground({ children, gap, radius, glowRatio, color, glowColor, speed, className, }: DottedGlowBackgroundProps): react.JSX.Element;
|
|
1826
|
+
|
|
1827
|
+
type DraggableItem = {
|
|
1828
|
+
title: string;
|
|
1829
|
+
src?: string;
|
|
1830
|
+
/** Resting position, % of the table. */
|
|
1831
|
+
x: number;
|
|
1832
|
+
y: number;
|
|
1833
|
+
/** Resting tilt in degrees. */
|
|
1834
|
+
rotate?: number;
|
|
1835
|
+
};
|
|
1836
|
+
type DraggableCardsProps = {
|
|
1837
|
+
items?: DraggableItem[];
|
|
1838
|
+
/** Content shown on the table underneath the cards. */
|
|
1839
|
+
children?: ReactNode;
|
|
1840
|
+
/** Card width in px. */
|
|
1841
|
+
cardWidth?: number;
|
|
1842
|
+
/** 0–1: how quickly a flung card slows down (higher glides further). */
|
|
1843
|
+
friction?: number;
|
|
1844
|
+
className?: string;
|
|
1845
|
+
};
|
|
1846
|
+
declare function DraggableCards({ items, children, cardWidth, friction, className, }: DraggableCardsProps): react.JSX.Element;
|
|
1847
|
+
|
|
1848
|
+
type DraggableGridProps = {
|
|
1849
|
+
images?: string[];
|
|
1850
|
+
/** Tile size and spacing in px. */
|
|
1851
|
+
cellWidth?: number;
|
|
1852
|
+
cellHeight?: number;
|
|
1853
|
+
gap?: number;
|
|
1854
|
+
/** Idle drift speed in px per second; 0 stops it. */
|
|
1855
|
+
drift?: number;
|
|
1856
|
+
/** Fired when a tile is clicked (not dragged). */
|
|
1857
|
+
onSelect?: (index: number) => void;
|
|
1858
|
+
/** Height of the frame in px. */
|
|
1859
|
+
height?: number;
|
|
1860
|
+
className?: string;
|
|
1861
|
+
};
|
|
1862
|
+
declare function DraggableGrid({ images, cellWidth, cellHeight, gap, drift, onSelect, height, className, }: DraggableGridProps): react.JSX.Element;
|
|
1863
|
+
|
|
1864
|
+
type DrawPathProps = {
|
|
1865
|
+
/** SVG path data, one string per stroke, drawn in order. */
|
|
1866
|
+
paths?: string[];
|
|
1867
|
+
/** viewBox the paths were drawn in. */
|
|
1868
|
+
viewBox?: string;
|
|
1869
|
+
/** Play once on view, or follow scroll position. */
|
|
1870
|
+
trigger?: "view" | "scroll";
|
|
1871
|
+
stroke?: string;
|
|
1872
|
+
strokeWidth?: number;
|
|
1873
|
+
/** Fill colour faded in after drawing (view mode). */
|
|
1874
|
+
fill?: string;
|
|
1875
|
+
/** Length (ms) of each stroke (view mode). */
|
|
1876
|
+
duration?: number;
|
|
1877
|
+
/** Delay (ms) between strokes; negative overlaps them. */
|
|
1878
|
+
stagger?: number;
|
|
1879
|
+
/** Accessible description. */
|
|
1880
|
+
label?: string;
|
|
1881
|
+
className?: string;
|
|
1882
|
+
};
|
|
1883
|
+
declare function DrawPath({ paths, viewBox, trigger, stroke, strokeWidth, fill, duration, stagger, label, className, }: DrawPathProps): react.JSX.Element;
|
|
1884
|
+
|
|
1885
|
+
declare const EFFECT_BUTTON_VARIANTS: readonly ["shimmer", "glow", "sketch", "lift", "outline", "gradient", "invert", "spotlight", "arrow"];
|
|
1886
|
+
type EffectButtonVariant = (typeof EFFECT_BUTTON_VARIANTS)[number];
|
|
1887
|
+
type EffectButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
|
|
1888
|
+
variant?: EffectButtonVariant;
|
|
1889
|
+
size?: "sm" | "md" | "lg";
|
|
1890
|
+
children?: ReactNode;
|
|
1891
|
+
};
|
|
1892
|
+
declare function EffectButton({ variant, size, className, children, onPointerMove, style, type, ...props }: EffectButtonProps): react.JSX.Element;
|
|
1893
|
+
|
|
1894
|
+
type EncryptedTextProps = {
|
|
1895
|
+
text?: string;
|
|
1896
|
+
/** Milliseconds between each character locking in. */
|
|
1897
|
+
revealDelay?: number;
|
|
1898
|
+
/** Milliseconds between glyph swaps for unrevealed characters. */
|
|
1899
|
+
flipDelay?: number;
|
|
1900
|
+
/** Glyphs to scramble through. */
|
|
1901
|
+
charset?: string;
|
|
1902
|
+
/** Replay the reveal each time the pointer enters. */
|
|
1903
|
+
replayOnHover?: boolean;
|
|
1904
|
+
className?: string;
|
|
1905
|
+
/** Class for characters that are still scrambled. */
|
|
1906
|
+
scrambledClassName?: string;
|
|
1907
|
+
/** Class for characters that have locked in. */
|
|
1908
|
+
revealedClassName?: string;
|
|
1909
|
+
};
|
|
1910
|
+
declare function EncryptedText({ text, revealDelay, flipDelay, charset, replayOnHover, className, scrambledClassName, revealedClassName, }: EncryptedTextProps): react.JSX.Element;
|
|
1911
|
+
|
|
1912
|
+
type ExpandableItem = {
|
|
1913
|
+
title: string;
|
|
1914
|
+
description?: string;
|
|
1915
|
+
/** Image URL shown on the row and as the card's cover. */
|
|
1916
|
+
src?: string;
|
|
1917
|
+
/** Button label on the row and the expanded card. */
|
|
1918
|
+
ctaText?: string;
|
|
1919
|
+
ctaHref?: string;
|
|
1920
|
+
/** Shown only in the expanded card. */
|
|
1921
|
+
content?: ReactNode;
|
|
1922
|
+
};
|
|
1923
|
+
type ExpandableCardLabels = {
|
|
1924
|
+
close: string;
|
|
1925
|
+
};
|
|
1926
|
+
type ExpandableCardProps = {
|
|
1927
|
+
items?: ExpandableItem[];
|
|
1928
|
+
labels?: Partial<ExpandableCardLabels>;
|
|
1929
|
+
/** fired when a row is opened */
|
|
1930
|
+
onOpen?: (item: ExpandableItem, index: number) => void;
|
|
1931
|
+
className?: string;
|
|
1932
|
+
};
|
|
1933
|
+
declare function ExpandableCard({ items, labels, onOpen, className }: ExpandableCardProps): react.JSX.Element;
|
|
1934
|
+
|
|
1935
|
+
type ExpandingPanel = {
|
|
1936
|
+
image: string;
|
|
1937
|
+
title: string;
|
|
1938
|
+
description?: ReactNode;
|
|
1939
|
+
};
|
|
1940
|
+
type ExpandingPanelsProps = {
|
|
1941
|
+
panels?: ExpandingPanel[];
|
|
1942
|
+
/** Panel open at the start. */
|
|
1943
|
+
defaultIndex?: number;
|
|
1944
|
+
/** Open panels on hover (default) or only on click. */
|
|
1945
|
+
trigger?: "hover" | "click";
|
|
1946
|
+
onChange?: (index: number) => void;
|
|
1947
|
+
/** Height in px. */
|
|
1948
|
+
height?: number;
|
|
1949
|
+
className?: string;
|
|
1950
|
+
};
|
|
1951
|
+
declare function ExpandingPanels({ panels, defaultIndex, trigger, onChange, height, className, }: ExpandingPanelsProps): react.JSX.Element;
|
|
1952
|
+
|
|
1953
|
+
type FileUploadLabels = {
|
|
1954
|
+
title: string;
|
|
1955
|
+
hint: string;
|
|
1956
|
+
drop: string;
|
|
1957
|
+
modified: string;
|
|
1958
|
+
};
|
|
1959
|
+
type FileUploadProps = {
|
|
1960
|
+
onChange?: (files: File[]) => void;
|
|
1961
|
+
/** Passed to the file input, e.g. "image/*,.pdf". */
|
|
1962
|
+
accept?: string;
|
|
1963
|
+
multiple?: boolean;
|
|
1964
|
+
labels?: Partial<FileUploadLabels>;
|
|
1965
|
+
className?: string;
|
|
1966
|
+
};
|
|
1967
|
+
declare function FileUpload({ onChange, accept, multiple, labels, className }: FileUploadProps): react.JSX.Element;
|
|
1968
|
+
|
|
1969
|
+
type FlipGridItem = {
|
|
1970
|
+
id: string;
|
|
1971
|
+
title: string;
|
|
1972
|
+
image?: string;
|
|
1973
|
+
/** Filter tags this card belongs to. */
|
|
1974
|
+
tags?: string[];
|
|
1975
|
+
meta?: ReactNode;
|
|
1976
|
+
};
|
|
1977
|
+
type FlipGridLabels = {
|
|
1978
|
+
all: string;
|
|
1979
|
+
shuffle: string;
|
|
1980
|
+
};
|
|
1981
|
+
type FlipGridProps = {
|
|
1982
|
+
items?: FlipGridItem[];
|
|
1983
|
+
/** Show the shuffle button. */
|
|
1984
|
+
shuffle?: boolean;
|
|
1985
|
+
onFilterChange?: (tag: string | null) => void;
|
|
1986
|
+
/** Minimum card width in px. */
|
|
1987
|
+
minCardWidth?: number;
|
|
1988
|
+
labels?: Partial<FlipGridLabels>;
|
|
1989
|
+
className?: string;
|
|
1990
|
+
};
|
|
1991
|
+
declare function FlipGrid({ items, shuffle, onFilterChange, minCardWidth, labels, className }: FlipGridProps): react.JSX.Element;
|
|
1992
|
+
|
|
1993
|
+
type FlipWordsProps = {
|
|
1994
|
+
words?: string[];
|
|
1995
|
+
/** Milliseconds each word stays on screen. */
|
|
1996
|
+
duration?: number;
|
|
1997
|
+
className?: string;
|
|
1998
|
+
};
|
|
1999
|
+
declare function FlipWords({ words, duration, className, }: FlipWordsProps): react.JSX.Element;
|
|
2000
|
+
|
|
2001
|
+
type DockItem = {
|
|
2002
|
+
title: string;
|
|
2003
|
+
icon: ReactNode;
|
|
2004
|
+
href?: string;
|
|
2005
|
+
onClick?: () => void;
|
|
2006
|
+
};
|
|
2007
|
+
type FloatingDockProps = {
|
|
2008
|
+
items?: DockItem[];
|
|
2009
|
+
/** Resting icon tile size (px). */
|
|
2010
|
+
baseSize?: number;
|
|
2011
|
+
/** Size of the tile directly under the pointer (px). */
|
|
2012
|
+
maxSize?: number;
|
|
2013
|
+
/** How far (px) from the pointer tiles still grow. */
|
|
2014
|
+
distance?: number;
|
|
2015
|
+
className?: string;
|
|
2016
|
+
};
|
|
2017
|
+
declare function FloatingDock({ items, baseSize, maxSize, distance, className, }: FloatingDockProps): react.JSX.Element;
|
|
2018
|
+
|
|
2019
|
+
type FloatingNavItem = {
|
|
2020
|
+
label: string;
|
|
2021
|
+
href: string;
|
|
2022
|
+
/** Shown instead of the label on narrow screens. */
|
|
2023
|
+
icon?: ReactNode;
|
|
2024
|
+
};
|
|
2025
|
+
type FloatingNavbarProps = {
|
|
2026
|
+
items?: FloatingNavItem[];
|
|
2027
|
+
/** Anything on the right, e.g. a sign-in button. */
|
|
2028
|
+
action?: ReactNode;
|
|
2029
|
+
/** Fired when a link is chosen; call preventDefault on the event to route client-side. */
|
|
2030
|
+
onNavigate?: (href: string, event: MouseEvent<HTMLAnchorElement>) => void;
|
|
2031
|
+
/** Pin to the top of the viewport (default) or sit in the normal flow. */
|
|
2032
|
+
fixed?: boolean;
|
|
2033
|
+
/** Always visible above this scroll distance (px). */
|
|
2034
|
+
threshold?: number;
|
|
2035
|
+
/** Marks a link as current. */
|
|
2036
|
+
activeHref?: string;
|
|
2037
|
+
className?: string;
|
|
2038
|
+
};
|
|
2039
|
+
declare function FloatingNavbar({ items, action, onNavigate, fixed, threshold, activeHref, className, }: FloatingNavbarProps): react.JSX.Element;
|
|
2040
|
+
|
|
2041
|
+
type FocusCard = {
|
|
2042
|
+
title: string;
|
|
2043
|
+
src: string;
|
|
2044
|
+
};
|
|
2045
|
+
type FocusCardsProps = {
|
|
2046
|
+
cards?: FocusCard[];
|
|
2047
|
+
/** fired when a card is clicked */
|
|
2048
|
+
onSelect?: (card: FocusCard, index: number) => void;
|
|
2049
|
+
className?: string;
|
|
2050
|
+
};
|
|
2051
|
+
declare function FocusCards({ cards, onSelect, className }: FocusCardsProps): react.JSX.Element;
|
|
2052
|
+
|
|
2053
|
+
type FollowingPointerProps = {
|
|
2054
|
+
children?: ReactNode;
|
|
2055
|
+
/** The tag beside the arrow, e.g. a name. Leave out for a bare arrow. */
|
|
2056
|
+
label?: ReactNode;
|
|
2057
|
+
/** Colour of the arrow and tag. */
|
|
2058
|
+
color?: string;
|
|
2059
|
+
className?: string;
|
|
2060
|
+
};
|
|
2061
|
+
declare function FollowingPointer({ children, label, color, className }: FollowingPointerProps): react.JSX.Element;
|
|
2062
|
+
|
|
2063
|
+
type GlareCardProps = {
|
|
2064
|
+
children?: ReactNode;
|
|
2065
|
+
/** Maximum tilt in degrees. */
|
|
2066
|
+
maxTilt?: number;
|
|
2067
|
+
className?: string;
|
|
2068
|
+
};
|
|
2069
|
+
declare function GlareCard({ children, maxTilt, className }: GlareCardProps): react.JSX.Element;
|
|
2070
|
+
|
|
2071
|
+
type Trigger = "hover" | "always" | "burst";
|
|
2072
|
+
type GlitchTextProps = {
|
|
2073
|
+
children?: ReactNode;
|
|
2074
|
+
/** When the glitch plays. */
|
|
2075
|
+
trigger?: Trigger;
|
|
2076
|
+
/** Seconds between bursts (burst mode). */
|
|
2077
|
+
every?: number;
|
|
2078
|
+
/** The two colour channels. */
|
|
2079
|
+
colors?: [string, string];
|
|
2080
|
+
className?: string;
|
|
2081
|
+
};
|
|
2082
|
+
type GlitchImageProps = {
|
|
2083
|
+
src?: string;
|
|
2084
|
+
alt?: string;
|
|
2085
|
+
trigger?: Trigger;
|
|
2086
|
+
every?: number;
|
|
2087
|
+
aspectRatio?: string;
|
|
2088
|
+
className?: string;
|
|
2089
|
+
};
|
|
2090
|
+
declare function GlitchImage({ src, alt, trigger, every, aspectRatio, className }: GlitchImageProps): react.JSX.Element;
|
|
2091
|
+
declare function GlitchText({ children, trigger, every, colors, className, }: GlitchTextProps): react.JSX.Element;
|
|
2092
|
+
|
|
2093
|
+
type GlobeMarker = {
|
|
2094
|
+
lat: number;
|
|
2095
|
+
lng: number;
|
|
2096
|
+
size?: number;
|
|
2097
|
+
};
|
|
2098
|
+
type GlobeProps = {
|
|
2099
|
+
markers?: GlobeMarker[];
|
|
2100
|
+
/** Land dot colour; defaults to the theme's ink colour. */
|
|
2101
|
+
dotColor?: string;
|
|
2102
|
+
markerColor?: string;
|
|
2103
|
+
/** Colour of the halo around the globe. */
|
|
2104
|
+
glowColor?: string;
|
|
2105
|
+
/** Number of sample points over the sphere; more is denser. */
|
|
2106
|
+
density?: number;
|
|
2107
|
+
/** Radians per second; 0 stops it. */
|
|
2108
|
+
autoRotate?: number;
|
|
2109
|
+
draggable?: boolean;
|
|
2110
|
+
/** Point that faces the viewer at the start. */
|
|
2111
|
+
focus?: {
|
|
2112
|
+
lat: number;
|
|
2113
|
+
lng: number;
|
|
2114
|
+
};
|
|
2115
|
+
/** Size of the square canvas in px (it shrinks to fit narrower containers). */
|
|
2116
|
+
size?: number;
|
|
2117
|
+
/** Accessible description. */
|
|
2118
|
+
label?: string;
|
|
2119
|
+
className?: string;
|
|
2120
|
+
};
|
|
2121
|
+
declare function Globe({ markers, dotColor, markerColor, glowColor, density, autoRotate, draggable, focus, size, label, className, }: GlobeProps): react.JSX.Element;
|
|
2122
|
+
|
|
2123
|
+
type GlowingEffectProps = {
|
|
2124
|
+
children?: ReactNode;
|
|
2125
|
+
/** Width of the lit arc in degrees. */
|
|
2126
|
+
spread?: number;
|
|
2127
|
+
/** How far (px) outside the card the pointer still lights it. */
|
|
2128
|
+
proximity?: number;
|
|
2129
|
+
/** Share of the card's middle (0–1) where the glow switches off. */
|
|
2130
|
+
inactiveZone?: number;
|
|
2131
|
+
/** Border thickness in px. */
|
|
2132
|
+
borderWidth?: number;
|
|
2133
|
+
/** Colours along the arc. */
|
|
2134
|
+
colors?: string[];
|
|
2135
|
+
/** Also draw a soft blurred glow outside the border. */
|
|
2136
|
+
glow?: boolean;
|
|
2137
|
+
/** Corner radius in px. */
|
|
2138
|
+
radius?: number;
|
|
2139
|
+
disabled?: boolean;
|
|
2140
|
+
className?: string;
|
|
2141
|
+
};
|
|
2142
|
+
declare function GlowingEffect({ children, spread, proximity, inactiveZone, borderWidth, colors, glow, radius, disabled, className, }: GlowingEffectProps): react.JSX.Element;
|
|
2143
|
+
|
|
2144
|
+
type GlowingStarsProps = {
|
|
2145
|
+
children?: ReactNode;
|
|
2146
|
+
columns?: number;
|
|
2147
|
+
rows?: number;
|
|
2148
|
+
/** How many stars glow at once while idle. */
|
|
2149
|
+
glowing?: number;
|
|
2150
|
+
/** Milliseconds between idle reshuffles. */
|
|
2151
|
+
interval?: number;
|
|
2152
|
+
glowColor?: string;
|
|
2153
|
+
className?: string;
|
|
2154
|
+
};
|
|
2155
|
+
declare function GlowingStars({ children, columns, rows, glowing, interval, glowColor, className, }: GlowingStarsProps): react.JSX.Element;
|
|
2156
|
+
|
|
2157
|
+
type GooeyInputLabels = {
|
|
2158
|
+
placeholder: string;
|
|
2159
|
+
open: string;
|
|
2160
|
+
submit: string;
|
|
2161
|
+
};
|
|
2162
|
+
type GooeyInputProps = {
|
|
2163
|
+
value?: string;
|
|
2164
|
+
defaultValue?: string;
|
|
2165
|
+
onChange?: (value: string) => void;
|
|
2166
|
+
/** Fired with the text when the user presses Enter or the button. */
|
|
2167
|
+
onSubmit?: (value: string) => void;
|
|
2168
|
+
/** Start open. */
|
|
2169
|
+
defaultExpanded?: boolean;
|
|
2170
|
+
/** Width (px) when open. */
|
|
2171
|
+
width?: number;
|
|
2172
|
+
labels?: Partial<GooeyInputLabels>;
|
|
2173
|
+
className?: string;
|
|
2174
|
+
};
|
|
2175
|
+
declare function GooeyInput({ value, defaultValue, onChange, onSubmit, defaultExpanded, width, labels, className, }: GooeyInputProps): react.JSX.Element;
|
|
2176
|
+
|
|
2177
|
+
type GooeyMenuItem = {
|
|
2178
|
+
label: string;
|
|
2179
|
+
href: string;
|
|
2180
|
+
};
|
|
2181
|
+
type GooeyStickyMenuProps = {
|
|
2182
|
+
items?: GooeyMenuItem[];
|
|
2183
|
+
/** Controlled active href; leave out to follow the sections on the page. */
|
|
2184
|
+
activeHref?: string;
|
|
2185
|
+
onNavigate?: (href: string, event: MouseEvent<HTMLAnchorElement>) => void;
|
|
2186
|
+
/** Pill colour and highlight colour. */
|
|
2187
|
+
color?: string;
|
|
2188
|
+
activeColor?: string;
|
|
2189
|
+
/** Stick to the top of the scrolling area. */
|
|
2190
|
+
sticky?: boolean;
|
|
2191
|
+
className?: string;
|
|
2192
|
+
};
|
|
2193
|
+
declare function GooeyStickyMenu({ items, activeHref, onNavigate, color, activeColor, sticky, className, }: GooeyStickyMenuProps): react.JSX.Element;
|
|
2194
|
+
|
|
2195
|
+
type GravityTag = {
|
|
2196
|
+
label: string;
|
|
2197
|
+
color?: string;
|
|
2198
|
+
textColor?: string;
|
|
2199
|
+
};
|
|
2200
|
+
type GravityTagsProps = {
|
|
2201
|
+
tags?: (string | GravityTag)[];
|
|
2202
|
+
/** Height of the box in px. */
|
|
2203
|
+
height?: number;
|
|
2204
|
+
/** Downward pull; 1 is normal. */
|
|
2205
|
+
gravity?: number;
|
|
2206
|
+
/** Bounciness, 0–1. */
|
|
2207
|
+
bounce?: number;
|
|
2208
|
+
className?: string;
|
|
2209
|
+
};
|
|
2210
|
+
declare function GravityTags({ tags, height, gravity, bounce, className }: GravityTagsProps): react.JSX.Element;
|
|
2211
|
+
|
|
2212
|
+
type GridBackgroundVariant = "grid" | "grid-small" | "dot";
|
|
2213
|
+
type GridBackgroundProps = {
|
|
2214
|
+
variant?: GridBackgroundVariant;
|
|
2215
|
+
/** Fade the pattern out toward the edges. */
|
|
2216
|
+
fade?: boolean;
|
|
2217
|
+
children?: ReactNode;
|
|
2218
|
+
className?: string;
|
|
2219
|
+
};
|
|
2220
|
+
declare function GridBackground({ variant, fade, children, className }: GridBackgroundProps): react.JSX.Element;
|
|
2221
|
+
|
|
2222
|
+
type HeroHighlightProps = {
|
|
2223
|
+
children?: ReactNode;
|
|
2224
|
+
/** Radius (px) of the brightened area around the pointer. */
|
|
2225
|
+
radius?: number;
|
|
2226
|
+
/** Class for the outer panel. */
|
|
2227
|
+
containerClassName?: string;
|
|
2228
|
+
className?: string;
|
|
2229
|
+
};
|
|
2230
|
+
declare function HeroHighlight({ children, radius, containerClassName, className }: HeroHighlightProps): react.JSX.Element;
|
|
2231
|
+
type HighlightProps = {
|
|
2232
|
+
children?: ReactNode;
|
|
2233
|
+
/** Marker colours, left to right. */
|
|
2234
|
+
colors?: [string, string];
|
|
2235
|
+
/** Seconds for the stroke to sweep across. */
|
|
2236
|
+
duration?: number;
|
|
2237
|
+
className?: string;
|
|
2238
|
+
};
|
|
2239
|
+
declare function Highlight({ children, colors, duration, className }: HighlightProps): react.JSX.Element;
|
|
2240
|
+
|
|
2241
|
+
type HeroProduct = {
|
|
2242
|
+
title: string;
|
|
2243
|
+
thumbnail: string;
|
|
2244
|
+
href?: string;
|
|
2245
|
+
};
|
|
2246
|
+
type HeroParallaxProps = {
|
|
2247
|
+
/** Headline block shown at the top. */
|
|
2248
|
+
children?: ReactNode;
|
|
2249
|
+
products?: HeroProduct[];
|
|
2250
|
+
/** How far (px) rows slide over the scroll. */
|
|
2251
|
+
distance?: number;
|
|
2252
|
+
className?: string;
|
|
2253
|
+
};
|
|
2254
|
+
declare function HeroParallax({ children, products, distance, className }: HeroParallaxProps): react.JSX.Element;
|
|
2255
|
+
|
|
2256
|
+
type HorizontalScrollProps = {
|
|
2257
|
+
/** The panels, laid out in a row. */
|
|
2258
|
+
children?: ReactNode;
|
|
2259
|
+
/** Height of the pinned view (any CSS length). */
|
|
2260
|
+
viewHeight?: string;
|
|
2261
|
+
/** Space between panels in px. */
|
|
2262
|
+
gap?: number;
|
|
2263
|
+
/** Show a thin progress bar along the bottom. */
|
|
2264
|
+
showProgress?: boolean;
|
|
2265
|
+
className?: string;
|
|
2266
|
+
/** Classes for the moving row. */
|
|
2267
|
+
trackClassName?: string;
|
|
2268
|
+
};
|
|
2269
|
+
declare function HorizontalScroll({ children, viewHeight, gap, showProgress, className, trackClassName, }: HorizontalScrollProps): react.JSX.Element;
|
|
2270
|
+
|
|
2271
|
+
type HoverBorderGradientProps = ButtonHTMLAttributes<HTMLButtonElement> & {
|
|
2272
|
+
/** Seconds for one orbit of the highlight. */
|
|
2273
|
+
duration?: number;
|
|
2274
|
+
/** Class for the inner face. */
|
|
2275
|
+
innerClassName?: string;
|
|
2276
|
+
};
|
|
2277
|
+
declare function HoverBorderGradient({ duration, className, innerClassName, children, style, ...props }: HoverBorderGradientProps): react.JSX.Element;
|
|
2278
|
+
|
|
2279
|
+
type HoverRevealItem = {
|
|
2280
|
+
title: string;
|
|
2281
|
+
image: string;
|
|
2282
|
+
href?: string;
|
|
2283
|
+
/** Small text on the right, e.g. a year or a count. */
|
|
2284
|
+
meta?: ReactNode;
|
|
2285
|
+
};
|
|
2286
|
+
type HoverRevealListProps = {
|
|
2287
|
+
items?: HoverRevealItem[];
|
|
2288
|
+
onSelect?: (item: HoverRevealItem, index: number, event: MouseEvent<HTMLAnchorElement>) => void;
|
|
2289
|
+
/** Picture width in px. */
|
|
2290
|
+
imageSize?: number;
|
|
2291
|
+
className?: string;
|
|
2292
|
+
};
|
|
2293
|
+
declare function HoverRevealList({ items, onSelect, imageSize, className }: HoverRevealListProps): react.JSX.Element;
|
|
2294
|
+
|
|
2295
|
+
type ImageDistortHoverProps = {
|
|
2296
|
+
/** Picture at rest. */
|
|
2297
|
+
image?: string;
|
|
2298
|
+
/** Picture on hover. */
|
|
2299
|
+
hoverImage?: string;
|
|
2300
|
+
alt?: string;
|
|
2301
|
+
/** Peak distortion in px. */
|
|
2302
|
+
intensity?: number;
|
|
2303
|
+
/** Noise scale; higher gives finer ripples. */
|
|
2304
|
+
frequency?: number;
|
|
2305
|
+
/** Transition length in ms. */
|
|
2306
|
+
duration?: number;
|
|
2307
|
+
aspectRatio?: string;
|
|
2308
|
+
className?: string;
|
|
2309
|
+
};
|
|
2310
|
+
declare function ImageDistortHover({ image, hoverImage, alt, intensity, frequency, duration, aspectRatio, className, }: ImageDistortHoverProps): react.JSX.Element;
|
|
2311
|
+
|
|
2312
|
+
type ImageGenerationLoaderLabels = {
|
|
2313
|
+
generating: string;
|
|
2314
|
+
done: string;
|
|
2315
|
+
};
|
|
2316
|
+
type ImageGenerationLoaderProps = {
|
|
2317
|
+
src?: string;
|
|
2318
|
+
alt?: string;
|
|
2319
|
+
/** Controlled progress, 0–1. Leave out to run on a timer. */
|
|
2320
|
+
progress?: number;
|
|
2321
|
+
/** Timer length (ms) when uncontrolled. */
|
|
2322
|
+
duration?: number;
|
|
2323
|
+
/** Start over after finishing (uncontrolled only). */
|
|
2324
|
+
loop?: boolean;
|
|
2325
|
+
onComplete?: () => void;
|
|
2326
|
+
/** Show the status chip with the percentage. */
|
|
2327
|
+
showStatus?: boolean;
|
|
2328
|
+
/** CSS aspect ratio of the frame. */
|
|
2329
|
+
aspectRatio?: string;
|
|
2330
|
+
labels?: Partial<ImageGenerationLoaderLabels>;
|
|
2331
|
+
className?: string;
|
|
2332
|
+
};
|
|
2333
|
+
declare function ImageGenerationLoader({ src, alt, progress, duration, loop, onComplete, showStatus, aspectRatio, labels, className, }: ImageGenerationLoaderProps): react.JSX.Element;
|
|
2334
|
+
|
|
2335
|
+
type ImageSequenceProps = {
|
|
2336
|
+
/** Frame image URLs, in order. */
|
|
2337
|
+
frames?: string[];
|
|
2338
|
+
/** How many screens of scrolling the sequence takes. */
|
|
2339
|
+
length?: number;
|
|
2340
|
+
/** Height of the pinned view (any CSS length). */
|
|
2341
|
+
viewHeight?: string;
|
|
2342
|
+
/** Fit frames inside the view or fill it. */
|
|
2343
|
+
fit?: "contain" | "cover";
|
|
2344
|
+
/** Content layered over the frames. */
|
|
2345
|
+
children?: ReactNode;
|
|
2346
|
+
/** Accessible description of the sequence. */
|
|
2347
|
+
label?: string;
|
|
2348
|
+
className?: string;
|
|
2349
|
+
};
|
|
2350
|
+
declare function ImageSequence({ frames, length, viewHeight, fit, children, label, className, }: ImageSequenceProps): react.JSX.Element;
|
|
2351
|
+
|
|
2352
|
+
type ImageTrailProps = {
|
|
2353
|
+
images?: string[];
|
|
2354
|
+
/** Pointer distance (px) between two pictures. */
|
|
2355
|
+
threshold?: number;
|
|
2356
|
+
/** Width of each picture in px (height follows its ratio). */
|
|
2357
|
+
size?: number;
|
|
2358
|
+
/** How each picture enters and leaves. */
|
|
2359
|
+
variant?: "pop" | "drift" | "spin";
|
|
2360
|
+
/** How long (ms) a picture stays before fading. */
|
|
2361
|
+
linger?: number;
|
|
2362
|
+
/** Content shown above the trail. */
|
|
2363
|
+
children?: ReactNode;
|
|
2364
|
+
/** Height of the area in px. */
|
|
2365
|
+
height?: number;
|
|
2366
|
+
className?: string;
|
|
2367
|
+
};
|
|
2368
|
+
declare function ImageTrail({ images, threshold, size, variant, linger, children, height, className, }: ImageTrailProps): react.JSX.Element;
|
|
2369
|
+
|
|
2370
|
+
type ImagesBadgeProps = {
|
|
2371
|
+
/** Badge text. */
|
|
2372
|
+
children?: ReactNode;
|
|
2373
|
+
/** Thumbnail URLs (the first four are shown). */
|
|
2374
|
+
images?: string[];
|
|
2375
|
+
/** Thumbnail size in px. */
|
|
2376
|
+
size?: number;
|
|
2377
|
+
/** Makes the badge a link. */
|
|
2378
|
+
href?: string;
|
|
2379
|
+
onClick?: () => void;
|
|
2380
|
+
className?: string;
|
|
2381
|
+
};
|
|
2382
|
+
declare function ImagesBadge({ children, images, size, href, onClick, className }: ImagesBadgeProps): react.JSX.Element;
|
|
2383
|
+
|
|
2384
|
+
type ImagesSliderLabels = {
|
|
2385
|
+
previous: string;
|
|
2386
|
+
next: string;
|
|
2387
|
+
goTo: (n: number) => string;
|
|
2388
|
+
};
|
|
2389
|
+
type ImagesSliderProps = {
|
|
2390
|
+
images?: string[];
|
|
2391
|
+
/** Content shown over the slides. */
|
|
2392
|
+
children?: ReactNode;
|
|
2393
|
+
autoplay?: boolean;
|
|
2394
|
+
/** Milliseconds per slide when autoplaying. */
|
|
2395
|
+
interval?: number;
|
|
2396
|
+
/** Which way new slides enter from. */
|
|
2397
|
+
direction?: "up" | "down";
|
|
2398
|
+
/** Darken the slides so text on top stays readable. */
|
|
2399
|
+
overlay?: boolean;
|
|
2400
|
+
labels?: Partial<ImagesSliderLabels>;
|
|
2401
|
+
className?: string;
|
|
2402
|
+
};
|
|
2403
|
+
declare function ImagesSlider({ images, children, autoplay, interval, direction, overlay, labels, className, }: ImagesSliderProps): react.JSX.Element;
|
|
2404
|
+
|
|
2405
|
+
type InertiaSliderLabels = {
|
|
2406
|
+
previous: string;
|
|
2407
|
+
next: string;
|
|
2408
|
+
};
|
|
2409
|
+
type InertiaSliderProps = {
|
|
2410
|
+
/** Each child is one slide. */
|
|
2411
|
+
children?: ReactNode;
|
|
2412
|
+
/** Slide width in px. */
|
|
2413
|
+
slideWidth?: number;
|
|
2414
|
+
/** Space between slides in px. */
|
|
2415
|
+
gap?: number;
|
|
2416
|
+
/** Show previous / next buttons. */
|
|
2417
|
+
showArrows?: boolean;
|
|
2418
|
+
onChange?: (index: number) => void;
|
|
2419
|
+
labels?: Partial<InertiaSliderLabels>;
|
|
2420
|
+
className?: string;
|
|
2421
|
+
};
|
|
2422
|
+
declare function InertiaSlider({ children, slideWidth, gap, showArrows, onChange, labels, className }: InertiaSliderProps): react.JSX.Element;
|
|
2423
|
+
|
|
2424
|
+
type MovingCardItem = {
|
|
2425
|
+
quote: string;
|
|
2426
|
+
name: string;
|
|
2427
|
+
title?: string;
|
|
2428
|
+
};
|
|
2429
|
+
type InfiniteMovingCardsProps = {
|
|
2430
|
+
items?: MovingCardItem[];
|
|
2431
|
+
direction?: "left" | "right";
|
|
2432
|
+
/** Preset speed, or seconds for one full loop. */
|
|
2433
|
+
speed?: "fast" | "normal" | "slow" | number;
|
|
2434
|
+
pauseOnHover?: boolean;
|
|
2435
|
+
className?: string;
|
|
2436
|
+
};
|
|
2437
|
+
declare function InfiniteMovingCards({ items, direction, speed, pauseOnHover, className, }: InfiniteMovingCardsProps): react.JSX.Element;
|
|
2438
|
+
|
|
2439
|
+
type KeyboardKey = {
|
|
2440
|
+
/** Text on the keycap. */
|
|
2441
|
+
label: string;
|
|
2442
|
+
/** `KeyboardEvent.code` this key mirrors (e.g. "KeyA", "Space"). */
|
|
2443
|
+
code: string;
|
|
2444
|
+
/** Width in key units (1 = a letter key). */
|
|
2445
|
+
width?: number;
|
|
2446
|
+
};
|
|
2447
|
+
type KeyboardProps = {
|
|
2448
|
+
/** Rows of keys; defaults to a standard US layout. */
|
|
2449
|
+
layout?: KeyboardKey[][];
|
|
2450
|
+
/** Light keys when the matching physical key is pressed. */
|
|
2451
|
+
listen?: boolean;
|
|
2452
|
+
/** Key codes to show highlighted, e.g. a shortcut you're teaching. */
|
|
2453
|
+
highlight?: string[];
|
|
2454
|
+
/** Size of one key unit in px. */
|
|
2455
|
+
unit?: number;
|
|
2456
|
+
/** fired when a key is clicked or pressed */
|
|
2457
|
+
onKeyPress?: (key: KeyboardKey) => void;
|
|
2458
|
+
className?: string;
|
|
2459
|
+
};
|
|
2460
|
+
declare const KEYBOARD_US: KeyboardKey[][];
|
|
2461
|
+
declare function Keyboard({ layout, listen, highlight, unit, onKeyPress, className, }: KeyboardProps): react.JSX.Element;
|
|
2462
|
+
|
|
2463
|
+
type LampEffectProps = {
|
|
2464
|
+
children?: ReactNode;
|
|
2465
|
+
/** Colour of the light. */
|
|
2466
|
+
color?: string;
|
|
2467
|
+
/** Background behind the light. */
|
|
2468
|
+
background?: string;
|
|
2469
|
+
className?: string;
|
|
2470
|
+
};
|
|
2471
|
+
declare function LampEffect({ children, color, background, className, }: LampEffectProps): react.JSX.Element;
|
|
2472
|
+
|
|
2473
|
+
type LaptopScrollProps = {
|
|
2474
|
+
/** Screenshot shown on the screen. */
|
|
2475
|
+
src?: string;
|
|
2476
|
+
/** Heading above the laptop. */
|
|
2477
|
+
title?: ReactNode;
|
|
2478
|
+
/** Small badge on the deck, e.g. a logo. */
|
|
2479
|
+
badge?: ReactNode;
|
|
2480
|
+
/** Total scroll length of the section, any CSS length. */
|
|
2481
|
+
scrollLength?: string;
|
|
2482
|
+
className?: string;
|
|
2483
|
+
};
|
|
2484
|
+
declare function LaptopScroll({ src, title, badge, scrollLength, className }: LaptopScrollProps): react.JSX.Element;
|
|
2485
|
+
|
|
2486
|
+
type LayoutGridCard = {
|
|
2487
|
+
src: string;
|
|
2488
|
+
alt?: string;
|
|
2489
|
+
/** Shown over the picture when it is open. */
|
|
2490
|
+
content?: ReactNode;
|
|
2491
|
+
/** Take two columns (wide) or two rows (tall). */
|
|
2492
|
+
span?: "wide" | "tall";
|
|
2493
|
+
};
|
|
2494
|
+
type LayoutGridProps = {
|
|
2495
|
+
cards?: LayoutGridCard[];
|
|
2496
|
+
onSelect?: (card: LayoutGridCard | null, index: number | null) => void;
|
|
2497
|
+
/** Height (px) of one grid row. */
|
|
2498
|
+
rowHeight?: number;
|
|
2499
|
+
className?: string;
|
|
2500
|
+
};
|
|
2501
|
+
declare function LayoutGrid({ cards, onSelect, rowHeight, className }: LayoutGridProps): react.JSX.Element;
|
|
2502
|
+
|
|
2503
|
+
type LayoutTextFlipProps = {
|
|
2504
|
+
/** The fixed phrase before the flipping word. */
|
|
2505
|
+
text?: string;
|
|
2506
|
+
words?: string[];
|
|
2507
|
+
/** Milliseconds each word stays. */
|
|
2508
|
+
interval?: number;
|
|
2509
|
+
className?: string;
|
|
2510
|
+
};
|
|
2511
|
+
declare function LayoutTextFlip({ text, words, interval, className }: LayoutTextFlipProps): react.JSX.Element;
|
|
2512
|
+
|
|
2513
|
+
type LensProps = {
|
|
2514
|
+
children?: ReactNode;
|
|
2515
|
+
/** Magnification. */
|
|
2516
|
+
zoom?: number;
|
|
2517
|
+
/** Lens diameter in px. */
|
|
2518
|
+
size?: number;
|
|
2519
|
+
/** Keep the lens at a fixed spot (in px) instead of following the pointer. */
|
|
2520
|
+
position?: {
|
|
2521
|
+
x: number;
|
|
2522
|
+
y: number;
|
|
2523
|
+
};
|
|
2524
|
+
className?: string;
|
|
2525
|
+
};
|
|
2526
|
+
declare function Lens({ children, zoom, size, position, className }: LensProps): react.JSX.Element;
|
|
2527
|
+
|
|
2528
|
+
declare const LINK_HOVER_VARIANTS: readonly ["sweep", "grow", "marker", "strike", "double", "wave"];
|
|
2529
|
+
type LinkHoverVariant = (typeof LINK_HOVER_VARIANTS)[number];
|
|
2530
|
+
type LinkHoverProps = AnchorHTMLAttributes<HTMLAnchorElement> & {
|
|
2531
|
+
variant?: LinkHoverVariant;
|
|
2532
|
+
/** Colour of the line or highlight. Defaults to the accent colour. */
|
|
2533
|
+
color?: string;
|
|
2534
|
+
children?: ReactNode;
|
|
2535
|
+
};
|
|
2536
|
+
declare function LinkHover({ variant, color, className, children, style, ...props }: LinkHoverProps): react.JSX.Element;
|
|
2537
|
+
|
|
2538
|
+
type LinkPreviewProps = {
|
|
2539
|
+
url?: string;
|
|
2540
|
+
/** Link text. Defaults to the URL's host name. */
|
|
2541
|
+
children?: ReactNode;
|
|
2542
|
+
/** Screenshot or image of the page. */
|
|
2543
|
+
image?: string;
|
|
2544
|
+
/** Shown on the generated card when there's no image. */
|
|
2545
|
+
title?: string;
|
|
2546
|
+
description?: string;
|
|
2547
|
+
width?: number;
|
|
2548
|
+
height?: number;
|
|
2549
|
+
/** Open in a new tab. */
|
|
2550
|
+
newTab?: boolean;
|
|
2551
|
+
className?: string;
|
|
2552
|
+
};
|
|
2553
|
+
declare function LinkPreview({ url, children, image, title, description, width, height, newTab, className, }: LinkPreviewProps): react.JSX.Element;
|
|
2554
|
+
|
|
2555
|
+
type LiquidGlassProps = {
|
|
2556
|
+
children?: ReactNode;
|
|
2557
|
+
/** Frost blur in px. */
|
|
2558
|
+
blur?: number;
|
|
2559
|
+
/** How strongly the edges bend what's behind (0 turns it off). */
|
|
2560
|
+
refraction?: number;
|
|
2561
|
+
/** Tint over the glass, any CSS colour. */
|
|
2562
|
+
tint?: string;
|
|
2563
|
+
/** Corner radius in px. */
|
|
2564
|
+
radius?: number;
|
|
2565
|
+
className?: string;
|
|
2566
|
+
};
|
|
2567
|
+
declare function LiquidGlass({ children, blur, refraction, tint, radius, className, }: LiquidGlassProps): react.JSX.Element;
|
|
2568
|
+
|
|
2569
|
+
type LoopSliderLabels = {
|
|
2570
|
+
previous: string;
|
|
2571
|
+
next: string;
|
|
2572
|
+
};
|
|
2573
|
+
type LoopSliderProps = {
|
|
2574
|
+
/** Each child is one slide. */
|
|
2575
|
+
children?: ReactNode;
|
|
2576
|
+
slideWidth?: number;
|
|
2577
|
+
gap?: number;
|
|
2578
|
+
/** Advance every this many ms; 0 turns it off. */
|
|
2579
|
+
autoplay?: number;
|
|
2580
|
+
showArrows?: boolean;
|
|
2581
|
+
onChange?: (index: number) => void;
|
|
2582
|
+
labels?: Partial<LoopSliderLabels>;
|
|
2583
|
+
className?: string;
|
|
2584
|
+
};
|
|
2585
|
+
declare function LoopSlider({ children, slideWidth, gap, autoplay, showArrows, onChange, labels, className, }: LoopSliderProps): react.JSX.Element;
|
|
2586
|
+
|
|
2587
|
+
type MagneticButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
|
|
2588
|
+
/** How strongly the button follows the pointer (0–1). */
|
|
2589
|
+
strength?: number;
|
|
2590
|
+
/** Extra distance (px) around the button where the pull starts. */
|
|
2591
|
+
radius?: number;
|
|
2592
|
+
children?: ReactNode;
|
|
2593
|
+
};
|
|
2594
|
+
declare function MagneticButton({ strength, radius, className, children, type, ...props }: MagneticButtonProps): react.JSX.Element;
|
|
2595
|
+
|
|
2596
|
+
type MagneticCursorProps = {
|
|
2597
|
+
children?: ReactNode;
|
|
2598
|
+
/** Which elements the ring snaps to. */
|
|
2599
|
+
selector?: string;
|
|
2600
|
+
/** Ring and dot colour. */
|
|
2601
|
+
color?: string;
|
|
2602
|
+
/** Ring diameter at rest in px. */
|
|
2603
|
+
size?: number;
|
|
2604
|
+
/** How far (0–1) a snapped target follows the pointer. */
|
|
2605
|
+
pull?: number;
|
|
2606
|
+
className?: string;
|
|
2607
|
+
};
|
|
2608
|
+
declare function MagneticCursor({ children, selector, color, size, pull, className, }: MagneticCursorProps): react.JSX.Element;
|
|
2609
|
+
|
|
2610
|
+
type Marquee3DProps = {
|
|
2611
|
+
images?: string[];
|
|
2612
|
+
/** Number of columns. */
|
|
2613
|
+
columns?: number;
|
|
2614
|
+
/** Seconds for one full loop of a column; lower is faster. */
|
|
2615
|
+
duration?: number;
|
|
2616
|
+
/** Height of the frame in px. */
|
|
2617
|
+
height?: number;
|
|
2618
|
+
className?: string;
|
|
2619
|
+
};
|
|
2620
|
+
declare function Marquee3D({ images, columns, duration, height, className }: Marquee3DProps): react.JSX.Element;
|
|
2621
|
+
|
|
2622
|
+
type MarqueeMenuItem = {
|
|
2623
|
+
label: string;
|
|
2624
|
+
href?: string;
|
|
2625
|
+
image?: string;
|
|
2626
|
+
};
|
|
2627
|
+
type MarqueeMenuProps = {
|
|
2628
|
+
items?: MarqueeMenuItem[];
|
|
2629
|
+
onSelect?: (item: MarqueeMenuItem, index: number, event: MouseEvent<HTMLAnchorElement>) => void;
|
|
2630
|
+
/** Band colour and its text colour. */
|
|
2631
|
+
bandColor?: string;
|
|
2632
|
+
bandTextColor?: string;
|
|
2633
|
+
/** Seconds for one loop of the ticker. */
|
|
2634
|
+
speed?: number;
|
|
2635
|
+
className?: string;
|
|
2636
|
+
};
|
|
2637
|
+
declare function MarqueeMenu({ items, onSelect, bandColor, bandTextColor, speed, className, }: MarqueeMenuProps): react.JSX.Element;
|
|
2638
|
+
|
|
2639
|
+
type MeteorsProps = {
|
|
2640
|
+
/** How many meteors. */
|
|
2641
|
+
number?: number;
|
|
2642
|
+
children?: ReactNode;
|
|
2643
|
+
className?: string;
|
|
2644
|
+
};
|
|
2645
|
+
declare function Meteors({ number, children, className }: MeteorsProps): react.JSX.Element;
|
|
2646
|
+
|
|
2647
|
+
type MorphingBlobProps = {
|
|
2648
|
+
/** Gradient colours, start to end. */
|
|
2649
|
+
colors?: [string, string];
|
|
2650
|
+
/** Fill the blob with a picture instead of the gradient. */
|
|
2651
|
+
image?: string;
|
|
2652
|
+
/** Diameter in px. */
|
|
2653
|
+
size?: number;
|
|
2654
|
+
/** Number of bumps around the edge. */
|
|
2655
|
+
points?: number;
|
|
2656
|
+
/** How far (0–0.4) the edge moves in and out. */
|
|
2657
|
+
wobble?: number;
|
|
2658
|
+
/** Speed multiplier. */
|
|
2659
|
+
speed?: number;
|
|
2660
|
+
/** Content centred on the blob. */
|
|
2661
|
+
children?: ReactNode;
|
|
2662
|
+
className?: string;
|
|
2663
|
+
};
|
|
2664
|
+
declare function MorphingBlob({ colors, image, size, points, wobble, speed, children, className, }: MorphingBlobProps): react.JSX.Element;
|
|
2665
|
+
|
|
2666
|
+
type MotionPathProps = {
|
|
2667
|
+
/** SVG path data for the route. */
|
|
2668
|
+
path?: string;
|
|
2669
|
+
/** viewBox the route was drawn in. */
|
|
2670
|
+
viewBox?: string;
|
|
2671
|
+
/** The element that travels (defaults to a glowing dot). */
|
|
2672
|
+
children?: ReactNode;
|
|
2673
|
+
/** Loop on a timer, or follow the scroll position. */
|
|
2674
|
+
mode?: "loop" | "scroll";
|
|
2675
|
+
/** Seconds per trip (loop mode). */
|
|
2676
|
+
duration?: number;
|
|
2677
|
+
/** Turn the traveller to face along the path. */
|
|
2678
|
+
autoRotate?: boolean;
|
|
2679
|
+
/** Show the route; the travelled part is highlighted. */
|
|
2680
|
+
showPath?: boolean;
|
|
2681
|
+
pathColor?: string;
|
|
2682
|
+
activeColor?: string;
|
|
2683
|
+
className?: string;
|
|
2684
|
+
};
|
|
2685
|
+
declare function MotionPath({ path, viewBox, children, mode, duration, autoRotate, showPath, pathColor, activeColor, className, }: MotionPathProps): react.JSX.Element;
|
|
2686
|
+
|
|
2687
|
+
type MovingBorderProps = ButtonHTMLAttributes<HTMLButtonElement> & {
|
|
2688
|
+
/** Milliseconds for one lap of the glow. */
|
|
2689
|
+
duration?: number;
|
|
2690
|
+
/** Corner radius in px (outer edge). */
|
|
2691
|
+
radius?: number;
|
|
2692
|
+
/** Border thickness in px. */
|
|
2693
|
+
borderWidth?: number;
|
|
2694
|
+
/** Colour of the travelling glow. Defaults to the accent token. */
|
|
2695
|
+
glowColor?: string;
|
|
2696
|
+
/** Class for the inner face of the button. */
|
|
2697
|
+
innerClassName?: string;
|
|
2698
|
+
};
|
|
2699
|
+
declare function MovingBorder({ duration, radius, borderWidth, glowColor, className, innerClassName, children, style, ...props }: MovingBorderProps): react.JSX.Element;
|
|
2700
|
+
|
|
2701
|
+
type NavbarLink = {
|
|
2702
|
+
title: string;
|
|
2703
|
+
href: string;
|
|
2704
|
+
description?: string;
|
|
2705
|
+
};
|
|
2706
|
+
type NavbarItem = {
|
|
2707
|
+
label: string;
|
|
2708
|
+
/** Where the item goes when it has no dropdown. */
|
|
2709
|
+
href?: string;
|
|
2710
|
+
/** Links shown in the dropdown. */
|
|
2711
|
+
links?: NavbarLink[];
|
|
2712
|
+
};
|
|
2713
|
+
type NavbarMenuProps = {
|
|
2714
|
+
items?: NavbarItem[];
|
|
2715
|
+
/** fired when a link is chosen; call preventDefault on the event to route client-side */
|
|
2716
|
+
onNavigate?: (href: string, event: React.MouseEvent<HTMLAnchorElement>) => void;
|
|
2717
|
+
className?: string;
|
|
2718
|
+
};
|
|
2719
|
+
declare function NavbarMenu({ items, onNavigate, className }: NavbarMenuProps): react.JSX.Element;
|
|
2720
|
+
|
|
2721
|
+
type NoiseBackgroundProps = {
|
|
2722
|
+
children?: ReactNode;
|
|
2723
|
+
/** Three or more colours for the drifting washes. */
|
|
2724
|
+
colors?: string[];
|
|
2725
|
+
/** Grain strength, 0–1. */
|
|
2726
|
+
grain?: number;
|
|
2727
|
+
/** Seconds for one full drift; lower is faster. 0 stops it. */
|
|
2728
|
+
duration?: number;
|
|
2729
|
+
/** Width (px) of the coloured rim; 0 fills the whole box. */
|
|
2730
|
+
inset?: number;
|
|
2731
|
+
className?: string;
|
|
2732
|
+
/** Classes for the inner panel (the area that holds children). */
|
|
2733
|
+
innerClassName?: string;
|
|
2734
|
+
};
|
|
2735
|
+
declare function NoiseBackground({ children, colors, grain, duration, inset, className, innerClassName, }: NoiseBackgroundProps): react.JSX.Element;
|
|
2736
|
+
|
|
2737
|
+
type NotchLabels = {
|
|
2738
|
+
expand: string;
|
|
2739
|
+
};
|
|
2740
|
+
type NotchProps = {
|
|
2741
|
+
/** The glance shown while closed, e.g. a status dot and a word. */
|
|
2742
|
+
collapsed?: ReactNode;
|
|
2743
|
+
/** The full panel shown while open. */
|
|
2744
|
+
children?: ReactNode;
|
|
2745
|
+
/** Controlled open state. */
|
|
2746
|
+
expanded?: boolean;
|
|
2747
|
+
defaultExpanded?: boolean;
|
|
2748
|
+
onExpandedChange?: (expanded: boolean) => void;
|
|
2749
|
+
/** Open on click (default) or on hover. */
|
|
2750
|
+
trigger?: "click" | "hover";
|
|
2751
|
+
/** Size (px) when closed and when open. */
|
|
2752
|
+
collapsedSize?: {
|
|
2753
|
+
width: number;
|
|
2754
|
+
height: number;
|
|
2755
|
+
};
|
|
2756
|
+
expandedSize?: {
|
|
2757
|
+
width: number;
|
|
2758
|
+
height: number;
|
|
2759
|
+
};
|
|
2760
|
+
labels?: Partial<NotchLabels>;
|
|
2761
|
+
className?: string;
|
|
2762
|
+
};
|
|
2763
|
+
declare function Notch({ collapsed, children, expanded, defaultExpanded, onExpandedChange, trigger, collapsedSize, expandedSize, labels, className, }: NotchProps): react.JSX.Element;
|
|
2764
|
+
|
|
2765
|
+
type OffCanvasMenuLabels = {
|
|
2766
|
+
close: string;
|
|
2767
|
+
};
|
|
2768
|
+
type OffCanvasMenuProps = {
|
|
2769
|
+
/** The menu panel's content. */
|
|
2770
|
+
menu?: ReactNode;
|
|
2771
|
+
/** The page content that the menu moves or covers. */
|
|
2772
|
+
children?: ReactNode;
|
|
2773
|
+
/** Controlled open state. */
|
|
2774
|
+
open?: boolean;
|
|
2775
|
+
defaultOpen?: boolean;
|
|
2776
|
+
onOpenChange?: (open: boolean) => void;
|
|
2777
|
+
side?: "left" | "right";
|
|
2778
|
+
effect?: "slide" | "push" | "reveal" | "rotate";
|
|
2779
|
+
/** Panel width in px. */
|
|
2780
|
+
width?: number;
|
|
2781
|
+
labels?: Partial<OffCanvasMenuLabels>;
|
|
2782
|
+
className?: string;
|
|
2783
|
+
/** Classes for the menu panel. */
|
|
2784
|
+
panelClassName?: string;
|
|
2785
|
+
};
|
|
2786
|
+
declare function OffCanvasMenu({ menu, children, open, defaultOpen, onOpenChange, side, effect, width, labels, className, panelClassName, }: OffCanvasMenuProps): react.JSX.Element;
|
|
2787
|
+
|
|
2788
|
+
type PageTransitionEffect = "slide" | "scale" | "fold" | "cube" | "tip" | "fade";
|
|
2789
|
+
type PageTransitionProps = {
|
|
2790
|
+
/** Identifies the current view; changing it plays the transition. */
|
|
2791
|
+
viewKey?: string | number;
|
|
2792
|
+
/** The current view. */
|
|
2793
|
+
children?: ReactNode;
|
|
2794
|
+
effect?: PageTransitionEffect;
|
|
2795
|
+
/** 1 moves forward (new view from the right), -1 moves back. */
|
|
2796
|
+
direction?: 1 | -1;
|
|
2797
|
+
/** Length in ms. */
|
|
2798
|
+
duration?: number;
|
|
2799
|
+
className?: string;
|
|
2800
|
+
};
|
|
2801
|
+
declare function PageTransition({ viewKey, children, effect, direction, duration, className, }: PageTransitionProps): react.JSX.Element;
|
|
2802
|
+
|
|
2803
|
+
type ParallaxImage = {
|
|
2804
|
+
src: string;
|
|
2805
|
+
alt?: string;
|
|
2806
|
+
/** Position of the image centre, % of the hero. */
|
|
2807
|
+
x: number;
|
|
2808
|
+
y: number;
|
|
2809
|
+
/** Width in px. */
|
|
2810
|
+
width: number;
|
|
2811
|
+
/** 0 (far, barely moves) … 1 (near, moves most). */
|
|
2812
|
+
depth: number;
|
|
2813
|
+
/** Resting tilt in degrees. */
|
|
2814
|
+
rotate?: number;
|
|
2815
|
+
};
|
|
2816
|
+
type ParallaxHeroImagesProps = {
|
|
2817
|
+
children?: ReactNode;
|
|
2818
|
+
images?: ParallaxImage[];
|
|
2819
|
+
/** Maximum shift in px for depth 1. */
|
|
2820
|
+
strength?: number;
|
|
2821
|
+
className?: string;
|
|
2822
|
+
};
|
|
2823
|
+
declare function ParallaxHeroImages({ children, images, strength, className }: ParallaxHeroImagesProps): react.JSX.Element;
|
|
2824
|
+
|
|
2825
|
+
type ParallaxScrollProps = {
|
|
2826
|
+
images?: string[];
|
|
2827
|
+
/** How far (px) the columns travel over the whole scroll. */
|
|
2828
|
+
distance?: number;
|
|
2829
|
+
className?: string;
|
|
2830
|
+
};
|
|
2831
|
+
declare function ParallaxScroll({ images, distance, className }: ParallaxScrollProps): react.JSX.Element;
|
|
2832
|
+
|
|
2833
|
+
type ParticleButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> & {
|
|
2834
|
+
onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
|
|
2835
|
+
/** Particle colour; defaults to the button's background colour. */
|
|
2836
|
+
particleColor?: string;
|
|
2837
|
+
/** Which way the crumble sweeps. */
|
|
2838
|
+
direction?: "left" | "right";
|
|
2839
|
+
/** How long (ms) the crumble takes. */
|
|
2840
|
+
duration?: number;
|
|
2841
|
+
/** Re-form after this many ms; 0 keeps it gone. */
|
|
2842
|
+
reformAfter?: number;
|
|
2843
|
+
children?: ReactNode;
|
|
2844
|
+
};
|
|
2845
|
+
declare function ParticleButton({ onClick, particleColor, direction, duration, reformAfter, className, children, disabled, type, ...props }: ParticleButtonProps): react.JSX.Element;
|
|
2846
|
+
|
|
2847
|
+
type ParticleTextProps = {
|
|
2848
|
+
text?: string;
|
|
2849
|
+
/** Any CSS font weight and family. */
|
|
2850
|
+
font?: string;
|
|
2851
|
+
/** Particle colour; defaults to the theme's ink colour. Pass several for a mix. */
|
|
2852
|
+
colors?: string[];
|
|
2853
|
+
/** Distance (px) between particles; smaller is denser. */
|
|
2854
|
+
gap?: number;
|
|
2855
|
+
/** Radius (px) of the pointer's push. */
|
|
2856
|
+
radius?: number;
|
|
2857
|
+
/** Height of the canvas in px. */
|
|
2858
|
+
height?: number;
|
|
2859
|
+
className?: string;
|
|
2860
|
+
};
|
|
2861
|
+
declare function ParticleText({ text, font, colors, gap, radius, height, className, }: ParticleTextProps): react.JSX.Element;
|
|
2862
|
+
|
|
2863
|
+
type Pin3DProps = {
|
|
2864
|
+
children?: ReactNode;
|
|
2865
|
+
/** Text of the floating tag. */
|
|
2866
|
+
title?: ReactNode;
|
|
2867
|
+
/** Where the tag links to. */
|
|
2868
|
+
href?: string;
|
|
2869
|
+
onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
|
|
2870
|
+
/** Colour of the beam and ripples. */
|
|
2871
|
+
color?: string;
|
|
2872
|
+
className?: string;
|
|
2873
|
+
/** Classes for the card itself. */
|
|
2874
|
+
cardClassName?: string;
|
|
2875
|
+
};
|
|
2876
|
+
declare function Pin3D({ children, title, href, onClick, color, className, cardClassName, }: Pin3DProps): react.JSX.Element;
|
|
2877
|
+
|
|
2878
|
+
type PixelatedCanvasProps = {
|
|
2879
|
+
src?: string;
|
|
2880
|
+
/** Canvas size in px. */
|
|
2881
|
+
width?: number;
|
|
2882
|
+
height?: number;
|
|
2883
|
+
/** Pixel cell size in px. */
|
|
2884
|
+
cellSize?: number;
|
|
2885
|
+
/** Gap between cells as a share of the cell, 0–0.5. */
|
|
2886
|
+
gap?: number;
|
|
2887
|
+
/** Cell shape. */
|
|
2888
|
+
shape?: "square" | "circle";
|
|
2889
|
+
/** How far (px) the pointer's push reaches. */
|
|
2890
|
+
radius?: number;
|
|
2891
|
+
/** How hard cells are pushed away. */
|
|
2892
|
+
strength?: number;
|
|
2893
|
+
className?: string;
|
|
2894
|
+
};
|
|
2895
|
+
declare function PixelatedCanvas({ src, width, height, cellSize, gap, shape, radius, strength, className, }: PixelatedCanvasProps): react.JSX.Element;
|
|
2896
|
+
|
|
2897
|
+
type PointerHighlightProps = {
|
|
2898
|
+
children?: ReactNode;
|
|
2899
|
+
/** Colour of the box and the cursor. */
|
|
2900
|
+
color?: string;
|
|
2901
|
+
/** Milliseconds the box takes to draw. */
|
|
2902
|
+
duration?: number;
|
|
2903
|
+
className?: string;
|
|
2904
|
+
/** Classes for the drawn box. */
|
|
2905
|
+
boxClassName?: string;
|
|
2906
|
+
};
|
|
2907
|
+
declare function PointerHighlight({ children, color, duration, className, boxClassName, }: PointerHighlightProps): react.JSX.Element;
|
|
2908
|
+
|
|
2909
|
+
type PreloaderCounterLabels = {
|
|
2910
|
+
loading: string;
|
|
2911
|
+
};
|
|
2912
|
+
type PreloaderCounterProps = {
|
|
2913
|
+
/** Controlled progress, 0–1. Leave out to run on a timer. */
|
|
2914
|
+
progress?: number;
|
|
2915
|
+
/** Timer length in ms. */
|
|
2916
|
+
duration?: number;
|
|
2917
|
+
/** How the curtain leaves. */
|
|
2918
|
+
exit?: "wipe" | "split";
|
|
2919
|
+
/** Cover the viewport (default) or just the nearest positioned parent. */
|
|
2920
|
+
fixed?: boolean;
|
|
2921
|
+
/** Fired once the curtain has gone. */
|
|
2922
|
+
onDone?: () => void;
|
|
2923
|
+
labels?: Partial<PreloaderCounterLabels>;
|
|
2924
|
+
className?: string;
|
|
2925
|
+
};
|
|
2926
|
+
declare function PreloaderCounter({ progress, duration, exit, fixed, onDone, labels, className, }: PreloaderCounterProps): react.JSX.Element | null;
|
|
2927
|
+
|
|
2928
|
+
type RainGlassProps = {
|
|
2929
|
+
src?: string;
|
|
2930
|
+
alt?: string;
|
|
2931
|
+
/** How rainy, 0–1. */
|
|
2932
|
+
intensity?: number;
|
|
2933
|
+
/** Blur (px) of the picture behind the glass. */
|
|
2934
|
+
blur?: number;
|
|
2935
|
+
/** Height in px. */
|
|
2936
|
+
height?: number;
|
|
2937
|
+
className?: string;
|
|
2938
|
+
};
|
|
2939
|
+
declare function RainGlass({ src, alt, intensity, blur, height, className }: RainGlassProps): react.JSX.Element;
|
|
2940
|
+
|
|
2941
|
+
type ResizableNavItem = {
|
|
2942
|
+
label: string;
|
|
2943
|
+
href: string;
|
|
2944
|
+
};
|
|
2945
|
+
type ResizableNavbarLabels = {
|
|
2946
|
+
openMenu: string;
|
|
2947
|
+
closeMenu: string;
|
|
2948
|
+
};
|
|
2949
|
+
type ResizableNavbarProps = {
|
|
2950
|
+
/** Brand mark on the left. */
|
|
2951
|
+
logo?: ReactNode;
|
|
2952
|
+
items?: ResizableNavItem[];
|
|
2953
|
+
/** Buttons on the right (and at the foot of the mobile menu). */
|
|
2954
|
+
actions?: ReactNode;
|
|
2955
|
+
/** Fired when a link is chosen; call preventDefault on the event to route client-side. */
|
|
2956
|
+
onNavigate?: (href: string, event: MouseEvent<HTMLAnchorElement>) => void;
|
|
2957
|
+
/** Scroll distance (px) after which the bar tucks in. */
|
|
2958
|
+
threshold?: number;
|
|
2959
|
+
/** Width (px) of the bar at rest and when tucked in. */
|
|
2960
|
+
width?: number;
|
|
2961
|
+
compactWidth?: number;
|
|
2962
|
+
/** How the bar stays on screen. */
|
|
2963
|
+
position?: "sticky" | "fixed" | "static";
|
|
2964
|
+
labels?: Partial<ResizableNavbarLabels>;
|
|
2965
|
+
className?: string;
|
|
2966
|
+
};
|
|
2967
|
+
declare function ResizableNavbar({ logo, items, actions, onNavigate, threshold, width, compactWidth, position, labels, className, }: ResizableNavbarProps): react.JSX.Element;
|
|
2968
|
+
|
|
2969
|
+
type RollingTextProps = {
|
|
2970
|
+
text?: string;
|
|
2971
|
+
/** Delay (ms) between letters. */
|
|
2972
|
+
stagger?: number;
|
|
2973
|
+
/** Duration (ms) of each letter's roll. */
|
|
2974
|
+
duration?: number;
|
|
2975
|
+
/** Optional different colour for the incoming copy. */
|
|
2976
|
+
hoverColor?: string;
|
|
2977
|
+
className?: string;
|
|
2978
|
+
};
|
|
2979
|
+
declare function RollingText({ text, stagger, duration, hoverColor, className }: RollingTextProps): react.JSX.Element;
|
|
2980
|
+
|
|
2981
|
+
type ScalesProps = {
|
|
2982
|
+
children?: ReactNode;
|
|
2983
|
+
/** Distance between ticks in px. */
|
|
2984
|
+
spacing?: number;
|
|
2985
|
+
/** A long, labelled tick every N ticks. */
|
|
2986
|
+
majorEvery?: number;
|
|
2987
|
+
/** Print numbers on the long ticks. */
|
|
2988
|
+
showLabels?: boolean;
|
|
2989
|
+
/** How far (px) from the pointer ticks react. */
|
|
2990
|
+
reach?: number;
|
|
2991
|
+
className?: string;
|
|
2992
|
+
};
|
|
2993
|
+
declare function Scales({ children, spacing, majorEvery, showLabels, reach, className, }: ScalesProps): react.JSX.Element;
|
|
2994
|
+
|
|
2995
|
+
type ScrollGridProps = {
|
|
2996
|
+
images?: string[];
|
|
2997
|
+
variant?: "tilt" | "spread" | "zoom" | "swing";
|
|
2998
|
+
columns?: number;
|
|
2999
|
+
/** Gap between tiles in px. */
|
|
3000
|
+
gap?: number;
|
|
3001
|
+
aspectRatio?: string;
|
|
3002
|
+
className?: string;
|
|
3003
|
+
};
|
|
3004
|
+
declare function ScrollGrid({ images, variant, columns, gap, aspectRatio, className }: ScrollGridProps): react.JSX.Element;
|
|
3005
|
+
|
|
3006
|
+
type ScrollLayout = "grid" | "row" | "stack";
|
|
3007
|
+
type ScrollLayoutItem = {
|
|
3008
|
+
image: string;
|
|
3009
|
+
title?: string;
|
|
3010
|
+
};
|
|
3011
|
+
type ScrollLayoutSwitchProps = {
|
|
3012
|
+
items?: ScrollLayoutItem[];
|
|
3013
|
+
/** The layouts to pass through, in order. */
|
|
3014
|
+
layouts?: ScrollLayout[];
|
|
3015
|
+
/** Height of the pinned view (any CSS length). */
|
|
3016
|
+
viewHeight?: string;
|
|
3017
|
+
className?: string;
|
|
3018
|
+
};
|
|
3019
|
+
declare function ScrollLayoutSwitch({ items, layouts, viewHeight, className }: ScrollLayoutSwitchProps): react.JSX.Element;
|
|
3020
|
+
|
|
3021
|
+
type ScrollPathsEffectProps = {
|
|
3022
|
+
children?: ReactNode;
|
|
3023
|
+
/** One colour per ribbon. */
|
|
3024
|
+
colors?: string[];
|
|
3025
|
+
/** Total scroll length of the section, any CSS length. */
|
|
3026
|
+
scrollLength?: string;
|
|
3027
|
+
className?: string;
|
|
3028
|
+
};
|
|
3029
|
+
declare function ScrollPathsEffect({ children, colors, scrollLength, className, }: ScrollPathsEffectProps): react.JSX.Element;
|
|
3030
|
+
|
|
3031
|
+
type ScrollToTopLabels = {
|
|
3032
|
+
label: string;
|
|
3033
|
+
};
|
|
3034
|
+
type ScrollToTopProps = {
|
|
3035
|
+
/** Show after this scroll distance (px). 0 always shows. */
|
|
3036
|
+
threshold?: number;
|
|
3037
|
+
/** Where to scroll to, in px from the top. */
|
|
3038
|
+
to?: number;
|
|
3039
|
+
/** Fastest and slowest glide (ms); longer pages take longer. */
|
|
3040
|
+
minDuration?: number;
|
|
3041
|
+
maxDuration?: number;
|
|
3042
|
+
/** Pin to the bottom corner of the screen (default) or sit in place. */
|
|
3043
|
+
fixed?: boolean;
|
|
3044
|
+
onClick?: () => void;
|
|
3045
|
+
labels?: Partial<ScrollToTopLabels>;
|
|
3046
|
+
className?: string;
|
|
3047
|
+
};
|
|
3048
|
+
declare function ScrollToTop({ threshold, to, minDuration, maxDuration, fixed, onClick, labels, className, }: ScrollToTopProps): react.JSX.Element;
|
|
3049
|
+
|
|
3050
|
+
type ScrollTypographyProps = {
|
|
3051
|
+
text?: string;
|
|
3052
|
+
/** How the letters move. */
|
|
3053
|
+
variant?: "flip" | "scatter" | "spread" | "wave";
|
|
3054
|
+
/** Keep the letters in place after they settle instead of animating back out. */
|
|
3055
|
+
settle?: boolean;
|
|
3056
|
+
className?: string;
|
|
3057
|
+
};
|
|
3058
|
+
declare function ScrollTypography({ text, variant, settle, className }: ScrollTypographyProps): react.JSX.Element;
|
|
3059
|
+
|
|
3060
|
+
type ScrollZoomImageProps = {
|
|
3061
|
+
src?: string;
|
|
3062
|
+
alt?: string;
|
|
3063
|
+
/** Overlay content shown once the picture is full size. */
|
|
3064
|
+
children?: ReactNode;
|
|
3065
|
+
/** Starting width, as a fraction of the view. */
|
|
3066
|
+
startWidth?: number;
|
|
3067
|
+
/** Starting height, as a fraction of the view. */
|
|
3068
|
+
startHeight?: number;
|
|
3069
|
+
/** How many screens of scrolling the zoom takes. */
|
|
3070
|
+
length?: number;
|
|
3071
|
+
/** Height of the pinned view (any CSS length). */
|
|
3072
|
+
viewHeight?: string;
|
|
3073
|
+
className?: string;
|
|
3074
|
+
};
|
|
3075
|
+
declare function ScrollZoomImage({ src, alt, children, startWidth, startHeight, length, viewHeight, className, }: ScrollZoomImageProps): react.JSX.Element;
|
|
3076
|
+
|
|
3077
|
+
type SeamTransitionProps = {
|
|
3078
|
+
/** The pinned hero. */
|
|
3079
|
+
hero?: ReactNode;
|
|
3080
|
+
/** The content that rises over it. */
|
|
3081
|
+
children?: ReactNode;
|
|
3082
|
+
variant?: "curve" | "inset" | "tilt";
|
|
3083
|
+
/** Height of the hero (any CSS length). */
|
|
3084
|
+
heroHeight?: string;
|
|
3085
|
+
className?: string;
|
|
3086
|
+
contentClassName?: string;
|
|
3087
|
+
};
|
|
3088
|
+
declare function SeamTransition({ hero, children, variant, heroHeight, className, contentClassName, }: SeamTransitionProps): react.JSX.Element;
|
|
3089
|
+
|
|
3090
|
+
type ShapeMorphProps = {
|
|
3091
|
+
/** SVG path data for each shape, in order. */
|
|
3092
|
+
shapes?: string[];
|
|
3093
|
+
/** Fill colour for each shape (cycles if fewer than shapes). */
|
|
3094
|
+
colors?: string[];
|
|
3095
|
+
viewBox?: string;
|
|
3096
|
+
/** When to move to the next shape. */
|
|
3097
|
+
trigger?: "auto" | "hover" | "click";
|
|
3098
|
+
/** Pause (ms) on each shape in auto mode. */
|
|
3099
|
+
interval?: number;
|
|
3100
|
+
/** Morph length in ms. */
|
|
3101
|
+
duration?: number;
|
|
3102
|
+
/** Points per outline; more is smoother. */
|
|
3103
|
+
detail?: number;
|
|
3104
|
+
onChange?: (index: number) => void;
|
|
3105
|
+
label?: string;
|
|
3106
|
+
className?: string;
|
|
3107
|
+
};
|
|
3108
|
+
declare function ShapeMorph({ shapes, colors, viewBox, trigger, interval, duration, detail, onChange, label, className, }: ShapeMorphProps): react.JSX.Element;
|
|
3109
|
+
|
|
3110
|
+
type ShootingStarsProps = {
|
|
3111
|
+
children?: ReactNode;
|
|
3112
|
+
/** Background stars per 10,000 px². */
|
|
3113
|
+
starDensity?: number;
|
|
3114
|
+
/** Milliseconds between shooting stars (random within the range). */
|
|
3115
|
+
minDelay?: number;
|
|
3116
|
+
maxDelay?: number;
|
|
3117
|
+
/** Shooting-star speed in px per frame. */
|
|
3118
|
+
minSpeed?: number;
|
|
3119
|
+
maxSpeed?: number;
|
|
3120
|
+
starColor?: string;
|
|
3121
|
+
trailColor?: string;
|
|
3122
|
+
background?: string;
|
|
3123
|
+
className?: string;
|
|
3124
|
+
};
|
|
3125
|
+
declare function ShootingStars({ children, starDensity, minDelay, maxDelay, minSpeed, maxSpeed, starColor, trailColor, background, className, }: ShootingStarsProps): react.JSX.Element;
|
|
3126
|
+
|
|
3127
|
+
type GlowInputProps = InputHTMLAttributes<HTMLInputElement> & {
|
|
3128
|
+
/** Colour of the glow that follows the pointer. */
|
|
3129
|
+
glowColor?: string;
|
|
3130
|
+
/** Classes for the wrapper that carries the glow. */
|
|
3131
|
+
wrapperClassName?: string;
|
|
3132
|
+
};
|
|
3133
|
+
declare function GlowInput({ glowColor, wrapperClassName, className, ...props }: GlowInputProps): react.JSX.Element;
|
|
3134
|
+
type SignupField = {
|
|
3135
|
+
name: string;
|
|
3136
|
+
label: string;
|
|
3137
|
+
type?: string;
|
|
3138
|
+
placeholder?: string;
|
|
3139
|
+
autoComplete?: string;
|
|
3140
|
+
required?: boolean;
|
|
3141
|
+
/** Share a row with the next half-width field. */
|
|
3142
|
+
half?: boolean;
|
|
3143
|
+
};
|
|
3144
|
+
type SignupProvider = {
|
|
3145
|
+
id: string;
|
|
3146
|
+
label: string;
|
|
3147
|
+
icon?: ReactNode;
|
|
3148
|
+
};
|
|
3149
|
+
type SignupFormLabels = {
|
|
3150
|
+
firstName: string;
|
|
3151
|
+
lastName: string;
|
|
3152
|
+
email: string;
|
|
3153
|
+
password: string;
|
|
3154
|
+
submit: string;
|
|
3155
|
+
submitting: string;
|
|
3156
|
+
divider: string;
|
|
3157
|
+
};
|
|
3158
|
+
type SignupFormProps = {
|
|
3159
|
+
title?: ReactNode;
|
|
3160
|
+
description?: ReactNode;
|
|
3161
|
+
/** Replace the standard name / email / password fields. */
|
|
3162
|
+
fields?: SignupField[];
|
|
3163
|
+
/** Sign-in-with buttons shown under the divider. */
|
|
3164
|
+
providers?: SignupProvider[];
|
|
3165
|
+
/** Receives every field's value by name. */
|
|
3166
|
+
onSubmit?: (values: Record<string, string>, event: FormEvent<HTMLFormElement>) => void;
|
|
3167
|
+
onProvider?: (id: string) => void;
|
|
3168
|
+
/** Disables the form and shows the submitting label. */
|
|
3169
|
+
submitting?: boolean;
|
|
3170
|
+
/** Anything under the form, e.g. terms or a sign-in link. */
|
|
3171
|
+
footer?: ReactNode;
|
|
3172
|
+
labels?: Partial<SignupFormLabels>;
|
|
3173
|
+
className?: string;
|
|
3174
|
+
};
|
|
3175
|
+
declare function SignupForm({ title, description, fields, providers, onSubmit, onProvider, submitting, footer, labels, className, }: SignupFormProps): react.JSX.Element;
|
|
3176
|
+
|
|
3177
|
+
type SmoothScrollProps = {
|
|
3178
|
+
children?: ReactNode;
|
|
3179
|
+
/** How quickly the content catches up, 0–1. Lower is smoother and laggier. */
|
|
3180
|
+
smoothness?: number;
|
|
3181
|
+
/** Scroll inside a panel of this height (px) instead of the window. */
|
|
3182
|
+
height?: number;
|
|
3183
|
+
className?: string;
|
|
3184
|
+
};
|
|
3185
|
+
declare function SmoothScroll({ children, smoothness, height, className }: SmoothScrollProps): react.JSX.Element;
|
|
3186
|
+
|
|
3187
|
+
type SparklesProps = {
|
|
3188
|
+
children?: ReactNode;
|
|
3189
|
+
/** Particles per 100,000 px² of area. */
|
|
3190
|
+
density?: number;
|
|
3191
|
+
minSize?: number;
|
|
3192
|
+
maxSize?: number;
|
|
3193
|
+
/** Multiplier for drift and twinkle speed. */
|
|
3194
|
+
speed?: number;
|
|
3195
|
+
/** Any CSS colour. Defaults to the ink token, so it follows dark mode. */
|
|
3196
|
+
particleColor?: string;
|
|
3197
|
+
className?: string;
|
|
3198
|
+
};
|
|
3199
|
+
declare function Sparkles({ children, density, minSize, maxSize, speed, particleColor, className, }: SparklesProps): react.JSX.Element;
|
|
3200
|
+
|
|
3201
|
+
type SplitTextRevealProps = {
|
|
3202
|
+
text?: string;
|
|
3203
|
+
/** Split into words or single letters. */
|
|
3204
|
+
by?: "word" | "char";
|
|
3205
|
+
/** The element to render. */
|
|
3206
|
+
as?: "h1" | "h2" | "h3" | "h4" | "p" | "span" | "div";
|
|
3207
|
+
/** Delay (ms) between pieces. */
|
|
3208
|
+
stagger?: number;
|
|
3209
|
+
/** Duration (ms) of each piece's rise. */
|
|
3210
|
+
duration?: number;
|
|
3211
|
+
/** Extra delay (ms) before the first piece. */
|
|
3212
|
+
delay?: number;
|
|
3213
|
+
/** Add a slight turn as pieces rise. */
|
|
3214
|
+
tilt?: boolean;
|
|
3215
|
+
className?: string;
|
|
3216
|
+
};
|
|
3217
|
+
declare function SplitTextReveal({ text, by, as, stagger, duration, delay, tilt, className, }: SplitTextRevealProps): react.JSX.Element;
|
|
3218
|
+
|
|
3219
|
+
type SpotlightProps = {
|
|
3220
|
+
children?: ReactNode;
|
|
3221
|
+
/** Beam colour. */
|
|
3222
|
+
color?: string;
|
|
3223
|
+
/** Where the beam comes from. */
|
|
3224
|
+
from?: "top-left" | "top-right";
|
|
3225
|
+
/** Beam strength, 0–1. */
|
|
3226
|
+
intensity?: number;
|
|
3227
|
+
className?: string;
|
|
3228
|
+
};
|
|
3229
|
+
declare function Spotlight({ children, color, from, intensity, className, }: SpotlightProps): react.JSX.Element;
|
|
3230
|
+
|
|
3231
|
+
type SpotlightCardProps = {
|
|
3232
|
+
children?: ReactNode;
|
|
3233
|
+
/** Spotlight radius in px. */
|
|
3234
|
+
radius?: number;
|
|
3235
|
+
/** Show the dot pattern inside the spotlight. */
|
|
3236
|
+
dots?: boolean;
|
|
3237
|
+
className?: string;
|
|
3238
|
+
};
|
|
3239
|
+
declare function SpotlightCard({ children, radius, dots, className }: SpotlightCardProps): react.JSX.Element;
|
|
3240
|
+
|
|
3241
|
+
type SpotlightNewProps = {
|
|
3242
|
+
children?: ReactNode;
|
|
3243
|
+
/** Light colour as "h, s%, l%" so it can be layered at different strengths. */
|
|
3244
|
+
hsl?: string;
|
|
3245
|
+
/** How far (px) the banks sway. */
|
|
3246
|
+
sway?: number;
|
|
3247
|
+
/** Seconds per sway. */
|
|
3248
|
+
duration?: number;
|
|
3249
|
+
/** Width of each beam in px. */
|
|
3250
|
+
beamWidth?: number;
|
|
3251
|
+
className?: string;
|
|
3252
|
+
};
|
|
3253
|
+
declare function SpotlightNew({ children, hsl, sway, duration, beamWidth, className, }: SpotlightNewProps): react.JSX.Element;
|
|
3254
|
+
|
|
3255
|
+
type SquigglyTextProps = {
|
|
3256
|
+
children?: ReactNode;
|
|
3257
|
+
/** How far (px) the letters bend. */
|
|
3258
|
+
intensity?: number;
|
|
3259
|
+
/** How many times per second the wobble changes. */
|
|
3260
|
+
fps?: number;
|
|
3261
|
+
/** Noise scale; higher is a finer, busier wobble. */
|
|
3262
|
+
frequency?: number;
|
|
3263
|
+
className?: string;
|
|
3264
|
+
};
|
|
3265
|
+
declare function SquigglyText({ children, intensity, fps, frequency, className }: SquigglyTextProps): react.JSX.Element;
|
|
3266
|
+
|
|
3267
|
+
type StackedCard = {
|
|
3268
|
+
title: string;
|
|
3269
|
+
body?: ReactNode;
|
|
3270
|
+
image?: string;
|
|
3271
|
+
/** Card background; defaults to the surface colour. */
|
|
3272
|
+
color?: string;
|
|
3273
|
+
/** Text colour for the card. */
|
|
3274
|
+
textColor?: string;
|
|
3275
|
+
};
|
|
3276
|
+
type StackedScrollCardsProps = {
|
|
3277
|
+
cards?: StackedCard[];
|
|
3278
|
+
/** Distance (px) from the top of the screen where cards pin. */
|
|
3279
|
+
top?: number;
|
|
3280
|
+
/** Extra offset (px) per card, so the stack's edges show. */
|
|
3281
|
+
offset?: number;
|
|
3282
|
+
/** Card height in px. */
|
|
3283
|
+
cardHeight?: number;
|
|
3284
|
+
className?: string;
|
|
3285
|
+
};
|
|
3286
|
+
declare function StackedScrollCards({ cards, top, offset, cardHeight, className }: StackedScrollCardsProps): react.JSX.Element;
|
|
3287
|
+
|
|
3288
|
+
type StaggerGridProps = {
|
|
3289
|
+
rows?: number;
|
|
3290
|
+
columns?: number;
|
|
3291
|
+
/** Dot size and spacing in px. */
|
|
3292
|
+
dotSize?: number;
|
|
3293
|
+
gap?: number;
|
|
3294
|
+
color?: string;
|
|
3295
|
+
/** Colour at the crest of the wave. */
|
|
3296
|
+
activeColor?: string;
|
|
3297
|
+
/** Delay (ms) per unit of distance from the source. */
|
|
3298
|
+
stagger?: number;
|
|
3299
|
+
/** How the dots move as the wave passes. */
|
|
3300
|
+
effect?: "lift" | "pulse" | "spin";
|
|
3301
|
+
/** Ripple from the centre on first view. */
|
|
3302
|
+
autoplay?: boolean;
|
|
3303
|
+
onCellClick?: (row: number, column: number) => void;
|
|
3304
|
+
className?: string;
|
|
3305
|
+
};
|
|
3306
|
+
declare function StaggerGrid({ rows, columns, dotSize, gap, color, activeColor, stagger, effect, autoplay, onCellClick, className, }: StaggerGridProps): react.JSX.Element;
|
|
3307
|
+
|
|
3308
|
+
type StatefulButtonState = "idle" | "loading" | "success" | "error";
|
|
3309
|
+
type StatefulButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> & {
|
|
3310
|
+
/** Return a promise to drive the loading → success / error states. */
|
|
3311
|
+
onClick?: (e: MouseEvent<HTMLButtonElement>) => unknown;
|
|
3312
|
+
/** How long the success / error state stays before returning to idle (ms). */
|
|
3313
|
+
resetAfter?: number;
|
|
3314
|
+
children?: ReactNode;
|
|
3315
|
+
};
|
|
3316
|
+
declare function StatefulButton({ onClick, resetAfter, className, children, disabled, ...props }: StatefulButtonProps): react.JSX.Element;
|
|
3317
|
+
|
|
3318
|
+
type StickyBannerLabels = {
|
|
3319
|
+
close: string;
|
|
3320
|
+
region: string;
|
|
3321
|
+
};
|
|
3322
|
+
type StickyBannerProps = {
|
|
3323
|
+
children?: ReactNode;
|
|
3324
|
+
/** Show a close button. */
|
|
3325
|
+
dismissible?: boolean;
|
|
3326
|
+
/** Fired after the banner is dismissed. */
|
|
3327
|
+
onClose?: () => void;
|
|
3328
|
+
/** Slide away after this scroll distance (px); set to 0 to always stay. */
|
|
3329
|
+
hideAfter?: number;
|
|
3330
|
+
labels?: Partial<StickyBannerLabels>;
|
|
3331
|
+
className?: string;
|
|
3332
|
+
};
|
|
3333
|
+
declare function StickyBanner({ children, dismissible, onClose, hideAfter, labels, className, }: StickyBannerProps): react.JSX.Element;
|
|
3334
|
+
|
|
3335
|
+
type StickySection = {
|
|
3336
|
+
title: string;
|
|
3337
|
+
description: string;
|
|
3338
|
+
/** What the pinned panel shows for this section. */
|
|
3339
|
+
content?: ReactNode;
|
|
3340
|
+
};
|
|
3341
|
+
type StickyScrollRevealProps = {
|
|
3342
|
+
items?: StickySection[];
|
|
3343
|
+
/** Box background per section (cycled). */
|
|
3344
|
+
backgrounds?: string[];
|
|
3345
|
+
/** Pinned panel background per section (cycled). */
|
|
3346
|
+
panelBackgrounds?: string[];
|
|
3347
|
+
/** Height of the scrolling box, any CSS length. */
|
|
3348
|
+
height?: string;
|
|
3349
|
+
className?: string;
|
|
3350
|
+
};
|
|
3351
|
+
declare function StickyScrollReveal({ items, backgrounds, panelBackgrounds, height, className, }: StickyScrollRevealProps): react.JSX.Element;
|
|
3352
|
+
|
|
3353
|
+
type SvgMaskEffectProps = {
|
|
3354
|
+
/** What's on the surface. */
|
|
3355
|
+
children?: ReactNode;
|
|
3356
|
+
/** What's seen through the lens. */
|
|
3357
|
+
revealContent?: ReactNode;
|
|
3358
|
+
/** Lens diameter in px while just hovering. */
|
|
3359
|
+
size?: number;
|
|
3360
|
+
/** Lens diameter in px over the revealed content. */
|
|
3361
|
+
revealSize?: number;
|
|
3362
|
+
className?: string;
|
|
3363
|
+
};
|
|
3364
|
+
declare function SvgMaskEffect({ children, revealContent, size, revealSize, className, }: SvgMaskEffectProps): react.JSX.Element;
|
|
3365
|
+
|
|
3366
|
+
type SwipeSectionsLabels = {
|
|
3367
|
+
goTo: string;
|
|
3368
|
+
};
|
|
3369
|
+
type SwipeSectionsProps = {
|
|
3370
|
+
/** Each child is one section. */
|
|
3371
|
+
children?: ReactNode;
|
|
3372
|
+
effect?: "slide" | "stack" | "fade";
|
|
3373
|
+
/** Height of the frame (any CSS length). */
|
|
3374
|
+
height?: string;
|
|
3375
|
+
/** Transition length in ms. */
|
|
3376
|
+
duration?: number;
|
|
3377
|
+
/** Show the dot navigation. */
|
|
3378
|
+
showDots?: boolean;
|
|
3379
|
+
onChange?: (index: number) => void;
|
|
3380
|
+
labels?: Partial<SwipeSectionsLabels>;
|
|
3381
|
+
className?: string;
|
|
3382
|
+
};
|
|
3383
|
+
declare function SwipeSections({ children, effect, height, duration, showDots, onChange, labels, className, }: SwipeSectionsProps): react.JSX.Element;
|
|
3384
|
+
|
|
3385
|
+
type TerminalLine = {
|
|
3386
|
+
/** "command" lines are typed after the prompt; "output" lines just appear. */
|
|
3387
|
+
type: "command" | "output";
|
|
3388
|
+
text: string;
|
|
3389
|
+
/** Colour for output lines, e.g. "var(--green)". */
|
|
3390
|
+
color?: string;
|
|
3391
|
+
/** Pause in ms before this line starts. */
|
|
3392
|
+
delay?: number;
|
|
3393
|
+
};
|
|
3394
|
+
type TerminalProps = {
|
|
3395
|
+
lines?: TerminalLine[];
|
|
3396
|
+
/** Window title. */
|
|
3397
|
+
title?: string;
|
|
3398
|
+
/** Prompt shown before commands. */
|
|
3399
|
+
prompt?: string;
|
|
3400
|
+
/** Milliseconds per typed character. */
|
|
3401
|
+
typingSpeed?: number;
|
|
3402
|
+
/** Start over after a pause once the session ends. */
|
|
3403
|
+
loop?: boolean;
|
|
3404
|
+
className?: string;
|
|
3405
|
+
};
|
|
3406
|
+
declare function Terminal({ lines, title, prompt, typingSpeed, loop, className, }: TerminalProps): react.JSX.Element;
|
|
3407
|
+
|
|
3408
|
+
type TextFlippingBoardProps = {
|
|
3409
|
+
/** Messages shown in turn; each is padded or cut to fit the board. */
|
|
3410
|
+
messages?: string[];
|
|
3411
|
+
/** Tiles per row. */
|
|
3412
|
+
columns?: number;
|
|
3413
|
+
/** Rows of tiles. */
|
|
3414
|
+
rows?: number;
|
|
3415
|
+
/** Milliseconds each message stays. */
|
|
3416
|
+
interval?: number;
|
|
3417
|
+
className?: string;
|
|
3418
|
+
};
|
|
3419
|
+
declare function TextFlippingBoard({ messages, columns, rows, interval, className, }: TextFlippingBoardProps): react.JSX.Element;
|
|
3420
|
+
|
|
3421
|
+
type TextHoverEffectProps = {
|
|
3422
|
+
text?: string;
|
|
3423
|
+
/** Colours of the lit outline, left to right. */
|
|
3424
|
+
colors?: string[];
|
|
3425
|
+
/** Radius of the lit area, % of the word's width. */
|
|
3426
|
+
radius?: number;
|
|
3427
|
+
/** Seconds for the outline to draw itself in. */
|
|
3428
|
+
drawDuration?: number;
|
|
3429
|
+
className?: string;
|
|
3430
|
+
};
|
|
3431
|
+
declare function TextHoverEffect({ text, colors, radius, drawDuration, className, }: TextHoverEffectProps): react.JSX.Element;
|
|
3432
|
+
|
|
3433
|
+
type TextOnPathProps = {
|
|
3434
|
+
text?: string;
|
|
3435
|
+
/** SVG path data the text follows. */
|
|
3436
|
+
path?: string;
|
|
3437
|
+
viewBox?: string;
|
|
3438
|
+
/** Follow scroll position or loop on its own. */
|
|
3439
|
+
mode?: "scroll" | "loop";
|
|
3440
|
+
/** Seconds per loop (loop mode). */
|
|
3441
|
+
duration?: number;
|
|
3442
|
+
/** Font size in viewBox units. */
|
|
3443
|
+
fontSize?: number;
|
|
3444
|
+
/** Repeat the text this many times along the path. */
|
|
3445
|
+
repeat?: number;
|
|
3446
|
+
color?: string;
|
|
3447
|
+
/** Draw the line under the text. */
|
|
3448
|
+
showPath?: boolean;
|
|
3449
|
+
className?: string;
|
|
3450
|
+
};
|
|
3451
|
+
declare function TextOnPath({ text, path, viewBox, mode, duration, fontSize, repeat, color, showPath, className, }: TextOnPathProps): react.JSX.Element;
|
|
3452
|
+
|
|
3453
|
+
type TextRevealCardProps = {
|
|
3454
|
+
/** The muted text shown at rest. */
|
|
3455
|
+
text?: string;
|
|
3456
|
+
/** The bright text revealed under the pointer. */
|
|
3457
|
+
revealText?: string;
|
|
3458
|
+
/** Heading content above the text (title, description). */
|
|
3459
|
+
children?: ReactNode;
|
|
3460
|
+
className?: string;
|
|
3461
|
+
};
|
|
3462
|
+
declare function TextRevealCard({ text, revealText, children, className }: TextRevealCardProps): react.JSX.Element;
|
|
3463
|
+
|
|
3464
|
+
type TileRevealProps = {
|
|
3465
|
+
src?: string;
|
|
3466
|
+
alt?: string;
|
|
3467
|
+
/** How the tiles clear. */
|
|
3468
|
+
mode?: "fade" | "pixel" | "flip";
|
|
3469
|
+
columns?: number;
|
|
3470
|
+
rows?: number;
|
|
3471
|
+
/** Total length of the reveal in ms. */
|
|
3472
|
+
duration?: number;
|
|
3473
|
+
/** Colour of the cover before the first picture. */
|
|
3474
|
+
coverColor?: string;
|
|
3475
|
+
aspectRatio?: string;
|
|
3476
|
+
className?: string;
|
|
3477
|
+
};
|
|
3478
|
+
declare function TileReveal({ src, alt, mode, columns, rows, duration, coverColor, aspectRatio, className, }: TileRevealProps): react.JSX.Element;
|
|
3479
|
+
|
|
3480
|
+
type TimelineEntry = {
|
|
3481
|
+
title: string;
|
|
3482
|
+
content: ReactNode;
|
|
3483
|
+
};
|
|
3484
|
+
type TimelineProps = {
|
|
3485
|
+
data?: TimelineEntry[];
|
|
3486
|
+
className?: string;
|
|
3487
|
+
};
|
|
3488
|
+
declare function Timeline({ data, className }: TimelineProps): react.JSX.Element;
|
|
3489
|
+
|
|
3490
|
+
type TooltipCardProps = {
|
|
3491
|
+
/** The inline trigger text. */
|
|
3492
|
+
children?: ReactNode;
|
|
3493
|
+
/** What the floating card shows. */
|
|
3494
|
+
content?: ReactNode;
|
|
3495
|
+
/** Card width in px. */
|
|
3496
|
+
width?: number;
|
|
3497
|
+
className?: string;
|
|
3498
|
+
};
|
|
3499
|
+
declare function TooltipCard({ children, content, width, className }: TooltipCardProps): react.JSX.Element;
|
|
3500
|
+
|
|
3501
|
+
type TracingBeamProps = {
|
|
3502
|
+
children?: ReactNode;
|
|
3503
|
+
/** Beam gradient colours, head to tail. */
|
|
3504
|
+
colors?: [string, string, string];
|
|
3505
|
+
/** Length of the beam in px. */
|
|
3506
|
+
beamLength?: number;
|
|
3507
|
+
className?: string;
|
|
3508
|
+
};
|
|
3509
|
+
declare function TracingBeam({ children, colors, beamLength, className, }: TracingBeamProps): react.JSX.Element;
|
|
3510
|
+
|
|
3511
|
+
type TransitionOverlayProps = {
|
|
3512
|
+
/** Change this value (e.g. increment a counter) to play the transition. */
|
|
3513
|
+
trigger?: number | string;
|
|
3514
|
+
variant?: "columns" | "circle" | "wave";
|
|
3515
|
+
/** Curtain colour. */
|
|
3516
|
+
color?: string;
|
|
3517
|
+
/** Number of columns (columns variant). */
|
|
3518
|
+
columns?: number;
|
|
3519
|
+
/** Length (ms) of each half: covering, then uncovering. */
|
|
3520
|
+
duration?: number;
|
|
3521
|
+
/** Where the circle opens from, as CSS percentages. */
|
|
3522
|
+
origin?: {
|
|
3523
|
+
x: string;
|
|
3524
|
+
y: string;
|
|
3525
|
+
};
|
|
3526
|
+
/** Fired at the midpoint, while the screen is covered. */
|
|
3527
|
+
onCovered?: () => void;
|
|
3528
|
+
/** Fired when the curtain has gone. */
|
|
3529
|
+
onDone?: () => void;
|
|
3530
|
+
/** Cover the viewport (default) or just the nearest positioned parent. */
|
|
3531
|
+
fixed?: boolean;
|
|
3532
|
+
className?: string;
|
|
3533
|
+
};
|
|
3534
|
+
declare function TransitionOverlay({ trigger, variant, color, columns, duration, origin, onCovered, onDone, fixed, className, }: TransitionOverlayProps): react.JSX.Element;
|
|
3535
|
+
|
|
3536
|
+
type TypewriterWord = {
|
|
3537
|
+
text: string;
|
|
3538
|
+
className?: string;
|
|
3539
|
+
};
|
|
3540
|
+
type TypewriterProps = {
|
|
3541
|
+
words?: TypewriterWord[];
|
|
3542
|
+
/** Milliseconds per character. */
|
|
3543
|
+
speed?: number;
|
|
3544
|
+
/** Erase and retype after a pause. */
|
|
3545
|
+
loop?: boolean;
|
|
3546
|
+
/** Pause at the end before erasing (ms), when looping. */
|
|
3547
|
+
pause?: number;
|
|
3548
|
+
className?: string;
|
|
3549
|
+
cursorClassName?: string;
|
|
3550
|
+
};
|
|
3551
|
+
declare function Typewriter({ words, speed, loop, pause, className, cursorClassName, }: TypewriterProps): react.JSX.Element;
|
|
3552
|
+
|
|
3553
|
+
type VelocityMarqueeProps = {
|
|
3554
|
+
/** One string per row. */
|
|
3555
|
+
rows?: string[];
|
|
3556
|
+
/** Resting drift in px per second. */
|
|
3557
|
+
speed?: number;
|
|
3558
|
+
/** How strongly scrolling speeds the rows up. */
|
|
3559
|
+
boost?: number;
|
|
3560
|
+
/** Lean (skew) the text with scroll speed. */
|
|
3561
|
+
skew?: boolean;
|
|
3562
|
+
/** Text placed between repeats. */
|
|
3563
|
+
separator?: string;
|
|
3564
|
+
className?: string;
|
|
3565
|
+
};
|
|
3566
|
+
declare function VelocityMarquee({ rows, speed, boost, skew, separator, className, }: VelocityMarqueeProps): react.JSX.Element;
|
|
3567
|
+
|
|
3568
|
+
type VortexProps = {
|
|
3569
|
+
children?: ReactNode;
|
|
3570
|
+
particleCount?: number;
|
|
3571
|
+
/** Starting hue (0–360) and how far hues spread from it. */
|
|
3572
|
+
baseHue?: number;
|
|
3573
|
+
rangeHue?: number;
|
|
3574
|
+
baseSpeed?: number;
|
|
3575
|
+
rangeSpeed?: number;
|
|
3576
|
+
/** Panel colour; trails fade into it. */
|
|
3577
|
+
backgroundColor?: string;
|
|
3578
|
+
className?: string;
|
|
3579
|
+
};
|
|
3580
|
+
declare function Vortex({ children, particleCount, baseHue, rangeHue, baseSpeed, rangeSpeed, backgroundColor, className, }: VortexProps): react.JSX.Element;
|
|
3581
|
+
|
|
3582
|
+
type WavyBackgroundProps = {
|
|
3583
|
+
children?: ReactNode;
|
|
3584
|
+
/** One colour per wave. */
|
|
3585
|
+
colors?: string[];
|
|
3586
|
+
/** Stroke width of each wave in px. */
|
|
3587
|
+
waveWidth?: number;
|
|
3588
|
+
/** Canvas fill behind the waves. Defaults to the page token. */
|
|
3589
|
+
backgroundFill?: string;
|
|
3590
|
+
/** Blur in px applied to the whole canvas. */
|
|
3591
|
+
blur?: number;
|
|
3592
|
+
speed?: "slow" | "fast";
|
|
3593
|
+
waveOpacity?: number;
|
|
3594
|
+
className?: string;
|
|
3595
|
+
};
|
|
3596
|
+
declare function WavyBackground({ children, colors, waveWidth, backgroundFill, blur, speed, waveOpacity, className, }: WavyBackgroundProps): react.JSX.Element;
|
|
3597
|
+
|
|
3598
|
+
type WebcamPixelGridLabels = {
|
|
3599
|
+
start: string;
|
|
3600
|
+
stop: string;
|
|
3601
|
+
denied: string;
|
|
3602
|
+
unsupported: string;
|
|
3603
|
+
};
|
|
3604
|
+
type WebcamPixelGridProps = {
|
|
3605
|
+
/** Grid cell size in px. */
|
|
3606
|
+
cellSize?: number;
|
|
3607
|
+
/** Dot colour. Defaults to the ink token; "camera" uses the camera's colours. */
|
|
3608
|
+
color?: string;
|
|
3609
|
+
/** Mirror horizontally, like a selfie view. */
|
|
3610
|
+
mirror?: boolean;
|
|
3611
|
+
/** Dot shape. */
|
|
3612
|
+
shape?: "circle" | "square";
|
|
3613
|
+
labels?: Partial<WebcamPixelGridLabels>;
|
|
3614
|
+
className?: string;
|
|
3615
|
+
};
|
|
3616
|
+
declare function WebcamPixelGrid({ cellSize, color, mirror, shape, labels, className, }: WebcamPixelGridProps): react.JSX.Element;
|
|
3617
|
+
|
|
3618
|
+
type WobbleCardProps = {
|
|
3619
|
+
children?: ReactNode;
|
|
3620
|
+
/** Card background, any CSS colour or gradient. */
|
|
3621
|
+
background?: string;
|
|
3622
|
+
/** How far (px) the card leans toward the pointer. */
|
|
3623
|
+
strength?: number;
|
|
3624
|
+
/** Class for the outer card. */
|
|
3625
|
+
containerClassName?: string;
|
|
3626
|
+
/** Class for the content area. */
|
|
3627
|
+
className?: string;
|
|
3628
|
+
};
|
|
3629
|
+
declare function WobbleCard({ children, background, strength, containerClassName, className, }: WobbleCardProps): react.JSX.Element;
|
|
3630
|
+
|
|
3631
|
+
type MapPoint = {
|
|
3632
|
+
lat: number;
|
|
3633
|
+
lng: number;
|
|
3634
|
+
label?: string;
|
|
3635
|
+
};
|
|
3636
|
+
type MapConnection = {
|
|
3637
|
+
from: MapPoint;
|
|
3638
|
+
to: MapPoint;
|
|
3639
|
+
};
|
|
3640
|
+
type WorldMapProps = {
|
|
3641
|
+
connections?: MapConnection[];
|
|
3642
|
+
/** Colour of the land dots. */
|
|
3643
|
+
dotColor?: string;
|
|
3644
|
+
/** Colour of the arcs and end points. */
|
|
3645
|
+
lineColor?: string;
|
|
3646
|
+
/** Grid spacing of the dots in degrees; smaller is denser. */
|
|
3647
|
+
spacing?: number;
|
|
3648
|
+
/** Seconds between one arc and the next. */
|
|
3649
|
+
stagger?: number;
|
|
3650
|
+
className?: string;
|
|
3651
|
+
};
|
|
3652
|
+
declare function WorldMap({ connections, dotColor, lineColor, spacing, stagger, className, }: WorldMapProps): react.JSX.Element;
|
|
3653
|
+
|
|
1154
3654
|
type NexiProviderProps = React.HTMLAttributes<HTMLDivElement> & {
|
|
1155
3655
|
/** Force the dark palette for this subtree. Leave undefined to inherit a
|
|
1156
3656
|
* `.dark` class from an ancestor (e.g. on <html>). */
|
|
@@ -1165,5 +3665,5 @@ declare function NexiProvider({ dark, contents, className, children, ...rest }:
|
|
|
1165
3665
|
/** Merge class names, letting later Tailwind classes win over conflicting earlier ones. */
|
|
1166
3666
|
declare function cn(...inputs: ClassValue[]): string;
|
|
1167
3667
|
|
|
1168
|
-
export { AgentScreen, ApprovalCard, Avatar, Badge, Button, ChatComposer, Chip, CodeBlock, ContextCards, Dialog, DiffTable, EmptyState, EntityChip, FilterTable, FineTuneCard, Flowchart, GlideMenu, InsightAllocationCard, InsightAnomalyCard, InsightCards, InsightCompareCard, InsightEntity, InsightMono, LoadingState, Markdown, Message, MessageThread, Monogram, NexiProvider, ProgressRing, PromptBar, RecommendationCard, SearchList, SegmentedControl, SelectionActions, Shimmer, SidebarNav, StatusPill, StreamText, StreamingText, Switch, TaskRows, TextRow, ThinkingState, ToastProvider, ToolChips, Tooltip, UsageMeter, ValuePill, badgeVariants, buttonVariants, cn, toStreamingTokens, useToast };
|
|
1169
|
-
export type { AgentScreenLabels, AgentScreenProps, AllocationSegment, AnomalyMetric, ApprovalCardProps, ApprovalLabels, ApprovalQuestion, AvatarProps, AvatarStatus, BadgeProps, BadgeTone, ButtonVariant, ChatComposerLabels, ChatComposerProps, ChatMessage, CodeBlockLabels, CodeBlockProps, CodePiece, CompareSeries, ContextCardsProps, ContextChunk, DialogLabels, DialogProps, DiffRow, DiffTableLabels, DiffTableProps, DiffTableRow, DiffTableTone, EmptyStateAction, EmptyStateProps, FilterTableLabels, FilterTableProps, FilterTableStatus, FineTuneCardLabels, FineTuneCardProps, FineTuneField, FineTuneState, FlowCondition, FlowEdge, FlowOption, FlowchartProps, GlideMenuProps, InsightAllocationCardProps, InsightAnomalyCardProps, InsightCardsLabels, InsightCardsProps, InsightCompareCardProps, InsightPage, LoadingStateProps, MarkdownProps, MessageProps, MessageThreadProps, NexiProviderProps, PromptBarLabels, PromptBarProps, PromptCommand, PromptModel, PromptSource, RecommendationCardProps, RecommendationLabels, RecommendationOption, SearchItem, SearchListLabels, SearchListProps, SelectionAction, SelectionActionSet, SelectionActionsLabels, SelectionActionsProps, SelectionText, SidebarMenuItem, SidebarNavItem, SidebarNavLabels, SidebarNavProps, SidebarRecent, SidebarWorkspace, StepNode, StreamingLabels, StreamingSource, StreamingTextProps, StreamingToken, TableRow, TaskDetail, TaskRow, TaskRowsLabels, TaskRowsProps, ThinkingRow, ThinkingStateProps, ThreadMessage, ToastOptions, ToastProviderProps, ToastTone, ToolChipsLabels, ToolChipsProps, ToolDetailLine, ToolDiff, ToolDiffLine, ToolStep, TooltipProps, UsageMeterProps, UsageSegment };
|
|
3668
|
+
export { AgentScreen, AnimatedModal, AnimatedTabs, AnimatedTestimonials, AnimatedTooltip, ApprovalCard, ArcGlobe, AsciiArt, AuroraBackground, Avatar, BackgroundBeams, BackgroundBoxes, BackgroundCubesGrid, BackgroundGradient, BackgroundGradientAnimation, BackgroundLines, BackgroundRippleEffect, Badge, BeamsWithCollision, BentoGrid, BentoGridItem, BlendCursor, BurstIcon, Button, CAPTION_HOVER_VARIANTS, CanvasRevealEffect, CanvasText, CaptionHover, Card3D, Card3DItem, CardHoverEffect, CardStack, CardsCarousel, Carousel3D, ChatComposer, Chip, ChromaticImage, CipherCard, CircularText, CloudShader, CodeBlock, ColourfulText, CometCard, Compare, ContainerCover, ContainerScrollAnimation, ContainerTextFlip, ContextCards, CountUp, Dialog, DiffTable, DirectionAwareHover, DitherShader, DottedGlowBackground, DraggableCards, DraggableGrid, DrawPath, EFFECT_BUTTON_VARIANTS, EffectButton, EmptyState, EncryptedText, EntityChip, ExpandableCard, ExpandingPanels, FileUpload, FilterTable, FineTuneCard, FlipGrid, FlipWords, FloatingDock, FloatingNavbar, Flowchart, FocusCards, FollowingPointer, GlareCard, GlideMenu, GlitchImage, GlitchText, Globe, GlowInput, GlowingEffect, GlowingStars, GooeyInput, GooeyStickyMenu, GravityTags, GridBackground, HeroHighlight, HeroParallax, Highlight, HorizontalScroll, HoverBorderGradient, HoverRevealList, ImageDistortHover, ImageGenerationLoader, ImageSequence, ImageTrail, ImagesBadge, ImagesSlider, InertiaSlider, InfiniteMovingCards, InsightAllocationCard, InsightAnomalyCard, InsightCards, InsightCompareCard, InsightEntity, InsightMono, KEYBOARD_US, Keyboard, LINK_HOVER_VARIANTS, LampEffect, LaptopScroll, LayoutGrid, LayoutTextFlip, Lens, LinkHover, LinkPreview, LiquidGlass, LoadingState, LoopSlider, MagneticButton, MagneticCursor, Markdown, Marquee3D, MarqueeMenu, Message, MessageThread, Meteors, Monogram, MorphingBlob, MotionPath, MovingBorder, NavbarMenu, NexiProvider, NoiseBackground, Notch, OffCanvasMenu, PageTransition, ParallaxHeroImages, ParallaxScroll, ParticleButton, ParticleText, Pin3D, PixelatedCanvas, PointerHighlight, PreloaderCounter, ProgressRing, PromptBar, RainGlass, RecommendationCard, ResizableNavbar, RollingText, Scales, ScrollGrid, ScrollLayoutSwitch, ScrollPathsEffect, ScrollToTop, ScrollTypography, ScrollZoomImage, SeamTransition, SearchList, SegmentedControl, SelectionActions, ShapeMorph, Shimmer, ShootingStars, SidebarNav, SignupForm, SmoothScroll, Sparkles, SplitTextReveal, Spotlight, SpotlightCard, SpotlightNew, SquigglyText, StackedScrollCards, StaggerGrid, StatefulButton, StatusPill, StickyBanner, StickyScrollReveal, StreamText, StreamingText, SvgMaskEffect, SwipeSections, Switch, TaskRows, Terminal, TextFlippingBoard, TextHoverEffect, TextOnPath, TextRevealCard, TextRow, ThinkingState, TileReveal, Timeline, ToastProvider, ToolChips, Tooltip, TooltipCard, TracingBeam, TransitionOverlay, Typewriter, UsageMeter, ValuePill, VelocityMarquee, Vortex, WavyBackground, WebcamPixelGrid, WobbleCard, WorldMap, badgeVariants, buttonVariants, cn, toStreamingTokens, useToast };
|
|
3669
|
+
export type { AgentScreenLabels, AgentScreenProps, AllocationSegment, AnimatedModalLabels, AnimatedModalProps, AnimatedTab, AnimatedTabsProps, AnimatedTestimonialsLabels, AnimatedTestimonialsProps, AnimatedTooltipProps, AnomalyMetric, ApprovalCardProps, ApprovalLabels, ApprovalQuestion, ArcGlobeProps, AsciiArtProps, AuroraBackgroundProps, AvatarProps, AvatarStatus, BackgroundBeamsProps, BackgroundBoxesProps, BackgroundCubesGridProps, BackgroundGradientAnimationProps, BackgroundGradientProps, BackgroundLinesProps, BackgroundRippleEffectProps, BadgeProps, BadgeTone, BeamsWithCollisionProps, BentoGridItemProps, BentoGridProps, BlendCursorProps, BurstIconProps, BurstIconShape, ButtonVariant, CanvasRevealEffectProps, CanvasTextProps, CaptionHoverProps, CaptionHoverVariant, Card3DItemProps, Card3DProps, CardHoverEffectProps, CardStackProps, CardsCarouselLabels, CardsCarouselProps, Carousel3DLabels, Carousel3DProps, Carousel3DSlide, CarouselCard, ChatComposerLabels, ChatComposerProps, ChatMessage, ChromaticImageProps, CipherCardProps, CircularTextProps, CloudShaderProps, CodeBlockLabels, CodeBlockProps, CodePiece, ColourfulTextProps, CometCardProps, CompareLabels, CompareProps, CompareSeries, ContainerCoverProps, ContainerScrollAnimationProps, ContainerTextFlipProps, ContextCardsProps, ContextChunk, CountUpProps, DialogLabels, DialogProps, DiffRow, DiffTableLabels, DiffTableProps, DiffTableRow, DiffTableTone, DirectionAwareHoverProps, DitherShaderProps, DockItem, DottedGlowBackgroundProps, DraggableCardsProps, DraggableGridProps, DraggableItem, DrawPathProps, EffectButtonProps, EffectButtonVariant, EmptyStateAction, EmptyStateProps, EncryptedTextProps, ExpandableCardLabels, ExpandableCardProps, ExpandableItem, ExpandingPanel, ExpandingPanelsProps, FallingBeam, FileUploadLabels, FileUploadProps, FilterTableLabels, FilterTableProps, FilterTableStatus, FineTuneCardLabels, FineTuneCardProps, FineTuneField, FineTuneState, FlipGridItem, FlipGridLabels, FlipGridProps, FlipWordsProps, FloatingDockProps, FloatingNavItem, FloatingNavbarProps, FlowCondition, FlowEdge, FlowOption, FlowchartProps, FocusCard, FocusCardsProps, FollowingPointerProps, GlareCardProps, GlideMenuProps, GlitchImageProps, GlitchTextProps, GlobeArc, GlobeMarker, GlobeProps, GlowInputProps, GlowingEffectProps, GlowingStarsProps, GooeyInputLabels, GooeyInputProps, GooeyMenuItem, GooeyStickyMenuProps, GradientOrb, GravityTag, GravityTagsProps, GridBackgroundProps, GridBackgroundVariant, HeroHighlightProps, HeroParallaxProps, HeroProduct, HighlightProps, HorizontalScrollProps, HoverBorderGradientProps, HoverCardItem, HoverRevealItem, HoverRevealListProps, ImageDistortHoverProps, ImageGenerationLoaderLabels, ImageGenerationLoaderProps, ImageSequenceProps, ImageTrailProps, ImagesBadgeProps, ImagesSliderLabels, ImagesSliderProps, InertiaSliderLabels, InertiaSliderProps, InfiniteMovingCardsProps, InsightAllocationCardProps, InsightAnomalyCardProps, InsightCardsLabels, InsightCardsProps, InsightCompareCardProps, InsightPage, KeyboardKey, KeyboardProps, LampEffectProps, LaptopScrollProps, LayoutGridCard, LayoutGridProps, LayoutTextFlipProps, LensProps, LinkHoverProps, LinkHoverVariant, LinkPreviewProps, LiquidGlassProps, LoadingStateProps, LoopSliderLabels, LoopSliderProps, MagneticButtonProps, MagneticCursorProps, MapConnection, MapPoint, MarkdownProps, Marquee3DProps, MarqueeMenuItem, MarqueeMenuProps, MessageProps, MessageThreadProps, MeteorsProps, MorphingBlobProps, MotionPathProps, MovingBorderProps, MovingCardItem, NavbarItem, NavbarLink, NavbarMenuProps, NexiProviderProps, NoiseBackgroundProps, NotchLabels, NotchProps, OffCanvasMenuLabels, OffCanvasMenuProps, PageTransitionEffect, PageTransitionProps, ParallaxHeroImagesProps, ParallaxImage, ParallaxScrollProps, ParticleButtonProps, ParticleTextProps, Pin3DProps, PixelatedCanvasProps, PointerHighlightProps, PreloaderCounterLabels, PreloaderCounterProps, PromptBarLabels, PromptBarProps, PromptCommand, PromptModel, PromptSource, RainGlassProps, RecommendationCardProps, RecommendationLabels, RecommendationOption, ResizableNavItem, ResizableNavbarLabels, ResizableNavbarProps, RollingTextProps, ScalesProps, ScrollGridProps, ScrollLayout, ScrollLayoutItem, ScrollLayoutSwitchProps, ScrollPathsEffectProps, ScrollToTopLabels, ScrollToTopProps, ScrollTypographyProps, ScrollZoomImageProps, SeamTransitionProps, SearchItem, SearchListLabels, SearchListProps, SelectionAction, SelectionActionSet, SelectionActionsLabels, SelectionActionsProps, SelectionText, ShapeMorphProps, ShootingStarsProps, SidebarMenuItem, SidebarNavItem, SidebarNavLabels, SidebarNavProps, SidebarRecent, SidebarWorkspace, SignupField, SignupFormLabels, SignupFormProps, SignupProvider, SmoothScrollProps, SparklesProps, SplitTextRevealProps, SpotlightCardProps, SpotlightNewProps, SpotlightProps, SquigglyTextProps, StackCard, StackedCard, StackedScrollCardsProps, StaggerGridProps, StatefulButtonProps, StatefulButtonState, StepNode, StickyBannerLabels, StickyBannerProps, StickyScrollRevealProps, StickySection, StreamingLabels, StreamingSource, StreamingTextProps, StreamingToken, SvgMaskEffectProps, SwipeSectionsLabels, SwipeSectionsProps, TableRow, TaskDetail, TaskRow, TaskRowsLabels, TaskRowsProps, TerminalLine, TerminalProps, Testimonial, TextFlippingBoardProps, TextHoverEffectProps, TextOnPathProps, TextRevealCardProps, ThinkingRow, ThinkingStateProps, ThreadMessage, TileRevealProps, TimelineEntry, TimelineProps, ToastOptions, ToastProviderProps, ToastTone, ToolChipsLabels, ToolChipsProps, ToolDetailLine, ToolDiff, ToolDiffLine, ToolStep, TooltipCardProps, TooltipPerson, TooltipProps, TracingBeamProps, TransitionOverlayProps, TypewriterProps, TypewriterWord, UsageMeterProps, UsageSegment, VelocityMarqueeProps, VortexProps, WavyBackgroundProps, WebcamPixelGridLabels, WebcamPixelGridProps, WobbleCardProps, WorldMapProps };
|