alouette
Version:
A modern, customizable design system built on top of NativeWind v5 with configurable defaults
1,773 lines (1,731 loc) • 97.5 kB
JavaScript
import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
import { createContext, useContext, forwardRef, Children, cloneElement, Fragment, useRef, useState, useEffect, isValidElement, useId, useReducer, useCallback, useMemo } from 'react';
import { useColorScheme, View as View$1, Text as Text$1, ScrollView as ScrollView$1, FlatList as FlatList$1, SectionList as SectionList$1, Pressable, Platform, useWindowDimensions, Modal as Modal$1, TextInput } from 'react-native-web';
import { extendTailwindMerge, twMerge as twMerge$1 } from 'tailwind-merge';
import { styled as styled$1, useUnstableNativeVariable } from 'nativewind';
import { tv } from 'tailwind-variants';
import { XRegularIcon } from 'alouette-icons/phosphor-icons/XRegularIcon';
import { CheckCircleRegularIcon } from 'alouette-icons/phosphor-icons/CheckCircleRegularIcon';
import { WarningDuotoneIcon } from 'alouette-icons/phosphor-icons/WarningDuotoneIcon';
import { CheckRegularIcon } from 'alouette-icons/phosphor-icons/CheckRegularIcon';
import { InfoRegularIcon } from 'alouette-icons/phosphor-icons/InfoRegularIcon';
import { QuestionRegularIcon } from 'alouette-icons/phosphor-icons/QuestionRegularIcon';
import { WarningRegularIcon } from 'alouette-icons/phosphor-icons/WarningRegularIcon';
import { ArrowSquareOutRegularIcon } from 'alouette-icons/phosphor-icons/ArrowSquareOutRegularIcon';
import { CaretDownRegularIcon } from 'alouette-icons/phosphor-icons/CaretDownRegularIcon';
import { AsteriskSimpleRegularIcon } from 'alouette-icons/phosphor-icons/AsteriskSimpleRegularIcon';
import { useForm, FormProvider, useFormContext, Controller, useFieldArray } from 'react-hook-form';
import { PlusRegularIcon } from 'alouette-icons/phosphor-icons/PlusRegularIcon';
import { TrashRegularIcon } from 'alouette-icons/phosphor-icons/TrashRegularIcon';
import { PencilSimpleRegularIcon } from 'alouette-icons/phosphor-icons/PencilSimpleRegularIcon';
import { CaretRightRegularIcon } from 'alouette-icons/phosphor-icons/CaretRightRegularIcon';
const ThemeContext = createContext("light");
function useCurrentTheme() {
return useContext(ThemeContext);
}
function useCurrentMode() {
return useContext(ThemeContext).startsWith("dark") ? "dark" : "light";
}
function ScopedTheme({ theme, children }) {
return /* @__PURE__ */ jsx(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ jsx("div", { "data-theme": theme, className: theme, style: { display: "contents" }, children }) });
}
function AlouetteProvider({
children
}) {
const colorScheme = useColorScheme();
return /* @__PURE__ */ jsx(ScopedTheme, { theme: colorScheme === "dark" ? "dark" : "light", children });
}
function SafeAreaProvider({ children }) {
return children;
}
const AlouetteDecorator = (storyFn, context) => {
const theme = context.globals.mode === "dark" ? "dark" : "light";
const themeVariables = context.parameters.alouette?.themeVariables;
if (!themeVariables) {
throw new Error(
'AlouetteDecorator: missing "themeVariables" in parameters.alouette'
);
}
return /* @__PURE__ */ jsx(SafeAreaProvider, { children: /* @__PURE__ */ jsx(AlouetteProvider, { themeVariables, children: /* @__PURE__ */ jsx(ScopedTheme, { theme, children: storyFn(context) }) }) });
};
const useSafeAreaInsets = () => ({
top: 0,
bottom: 0,
left: 0,
right: 0
});
const View = forwardRef((props, ref) => {
return /* @__PURE__ */ jsx(View$1, { ref, ...props });
});
function AccentScope({
mode: forcedMode,
accent,
children
}) {
const currentMode = useCurrentMode();
if (!accent) {
return children;
}
const mode = forcedMode ?? currentMode;
return /* @__PURE__ */ jsx(ScopedTheme, { theme: `${mode}_${accent}`, children });
}
const twMerge = extendTailwindMerge({
extend: {
classGroups: {
"font-family": [
"font-body",
"font-body-bold",
"font-body-extrabold",
"font-heading",
"font-heading-bold",
"font-heading-extrabold",
"font-mono",
"font-mono-bold",
"font-mono-extrabold"
]
}
}
});
const Text = forwardRef(
({ className, accent, ...props }, ref) => {
return /* @__PURE__ */ jsx(AccentScope, { accent, children: /* @__PURE__ */ jsx(
Text$1,
{
ref,
className: twMerge("font-body text-sharp", className),
...props
}
) });
}
);
const Paragraph = forwardRef(
({ className, ...props }, ref) => {
return /* @__PURE__ */ jsx(
Text,
{
ref,
role: "paragraph",
className: `select-auto ${className ?? ""}`,
...props
}
);
}
);
const ScrollView = styled$1(
ScrollView$1,
{
className: "style",
contentContainerClassName: "contentContainerStyle"
}
);
const FlatList = styled$1(
FlatList$1,
{
className: "style",
contentContainerClassName: "contentContainerStyle",
columnWrapperClassName: "columnWrapperStyle"
}
);
const SectionList = styled$1(
SectionList$1,
{
className: "style",
contentContainerClassName: "contentContainerStyle"
}
);
const Stack = forwardRef(
({ className, ...props }, ref) => {
return /* @__PURE__ */ jsx(
View$1,
{
ref,
className: `flex-row flex-wrap ${className ?? ""}`,
...props
}
);
}
);
const HStack = forwardRef(
({ className, ...props }, ref) => {
return /* @__PURE__ */ jsx(View$1, { ref, className: `flex-row ${className ?? ""}`, ...props });
}
);
const VStack = forwardRef(
({ className, ...props }, ref) => {
return /* @__PURE__ */ jsx(View$1, { ref, className: `flex-col ${className ?? ""}`, ...props });
}
);
const separatorVariants = tv({
base: "border-border-sharp",
variants: {
vertical: {
true: "self-stretch border-r w-px",
false: "self-stretch border-b h-px"
}
},
defaultVariants: {
vertical: false
}
});
const Separator = forwardRef(
({ className, vertical, ...props }, ref) => {
return /* @__PURE__ */ jsx(
View$1,
{
ref,
className: separatorVariants({ vertical, className }),
...props
}
);
}
);
const boxBaseClasses = "shrink";
const Box = forwardRef(
({ className, accent, ...props }, ref) => {
return /* @__PURE__ */ jsx(AccentScope, { accent, children: /* @__PURE__ */ jsx(
View$1,
{
ref,
className: `${boxBaseClasses} ${className ?? ""}`,
...props
}
) });
}
);
const interactiveBoxVariants = tv({
base: [
boxBaseClasses,
"cursor-pointer",
"transition-[transform,background-color,border-color] duration-fast ease-in",
"disabled:cursor-not-allowed disabled:opacity-70 aria-disabled:cursor-not-allowed aria-disabled:opacity-70",
"active:scale-[0.975]"
].join(" "),
variants: {
withFocusVisibleOutline: {
true: "focus-visible:outline-2 focus-visible:outline-offset-2"
}
}
});
const InteractiveBox = forwardRef(
({ withFocusVisibleOutline, className, ...rest }, ref) => /* @__PURE__ */ jsx(
Pressable,
{
ref,
pointerEvents: "auto",
...rest,
className: interactiveBoxVariants({ withFocusVisibleOutline, className })
}
)
);
const InteractiveBoxHitSlop = forwardRef(
({ withFocusVisibleOutline, children, className, ...rest }, ref) => {
const child = Children.only(children);
return /* @__PURE__ */ jsx(
Pressable,
{
ref,
pointerEvents: "auto",
className: `flex-center ${className ?? ""}`,
...rest,
children: cloneElement(child, {
className: interactiveBoxVariants({
withFocusVisibleOutline,
className: child.props.className
})
})
}
);
}
);
const SafeAreaBox = forwardRef(
(props, ref) => {
const insets = useSafeAreaInsets();
return /* @__PURE__ */ jsx(
Box,
{
ref,
style: {
paddingTop: insets.top,
paddingBottom: insets.bottom,
paddingLeft: insets.left,
paddingRight: insets.right
},
...props
}
);
}
);
const surfaceVariants = tv({
// overflow-hidden so the multi-layer shadow respects the rounded corners.
base: "overflow-hidden transition-background duration-fast",
variants: {
size: {
xxs: "p-xs rounded-xs",
xs: "p-sm rounded-xs",
sm: "p-m rounded-sm",
md: "p-xl rounded-sm",
lg: "p-xxl rounded-md"
},
variant: {
surface: "bg-surface",
highlight: "bg-highlight",
"highlight-accent": "bg-highlight-accent",
lowered: "bg-lowered",
translucent: "bg-translucent"
},
shadow: {
none: "shadow-none",
s: "shadow-s",
m: "shadow-m",
l: "shadow-l",
lowered: "shadow-lowered"
}
},
defaultVariants: {
size: "md",
variant: "surface"
}
});
const Surface = forwardRef(
({ className, size, variant, shadow, accent, ...props }, ref) => {
const resolvedShadow = shadow ?? (variant === "lowered" ? "lowered" : "s");
return /* @__PURE__ */ jsx(AccentScope, { accent, children: /* @__PURE__ */ jsx(
Box,
{
ref,
className: surfaceVariants({
size,
variant,
shadow: resolvedShadow,
className
}),
...props
}
) });
}
);
function styled(Component, defaultClassName) {
function StyledComponent({ className, ...props }) {
return /* @__PURE__ */ jsx(
Component,
{
className: twMerge$1(defaultClassName, className),
...props
}
);
}
StyledComponent.displayName = `Styled(${Component.displayName ?? Component.name ?? "Component"})`;
StyledComponent.__isStyledComponent = true;
return StyledComponent;
}
const storyTitleVariants = tv({
base: "font-heading-extrabold text-sharp",
variants: {
level: {
1: "text-4xl mb-xl",
2: "text-3xl mb-xl",
3: "text-2xl mb-m",
4: "text-xl mb-m"
}
},
defaultVariants: {
level: 1
}
});
const StoryTitle = forwardRef(
({ className, level, ...props }, ref) => {
return /* @__PURE__ */ jsx(
Text,
{
ref,
className: storyTitleVariants({ level, className }),
...props
}
);
}
);
const InternalStorySection = styled(View, "-mx-l px-l");
function StorySection({
title,
children,
level = 1,
modeTheme,
accent,
withSurface = false
}) {
const content = /* @__PURE__ */ jsx(InternalStorySection, { className: "pb-xl bg-screen", children: withSurface ? /* @__PURE__ */ jsxs(Surface, { children: [
/* @__PURE__ */ jsx(StoryTitle, { level: level + 1, children: title }),
/* @__PURE__ */ jsx(VStack, { className: "gap-m", children })
] }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
/* @__PURE__ */ jsx(StoryTitle, { level: level + 1, children: title }),
/* @__PURE__ */ jsx(VStack, { className: "gap-m", children })
] }) });
if (modeTheme) {
return /* @__PURE__ */ jsx(ScopedTheme, { theme: modeTheme, children: content });
}
if (accent) {
return /* @__PURE__ */ jsx(AccentScope, { accent, children: content });
}
return content;
}
function StorySubSection({
title,
children,
modeTheme,
accent,
withSurface = false
}) {
const content = /* @__PURE__ */ jsx(InternalStorySection, { className: "mb-m", children: withSurface ? /* @__PURE__ */ jsxs(Surface, { children: [
/* @__PURE__ */ jsx(StoryTitle, { level: 3, children: title }),
/* @__PURE__ */ jsx(VStack, { className: "gap-m", children })
] }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
/* @__PURE__ */ jsx(StoryTitle, { level: 3, children: title }),
/* @__PURE__ */ jsx(VStack, { className: "gap-m", children })
] }) });
if (modeTheme) {
return /* @__PURE__ */ jsx(ScopedTheme, { theme: modeTheme, children: content });
}
if (accent) {
return /* @__PURE__ */ jsx(AccentScope, { accent, children: content });
}
return content;
}
const ScrollWrapper = Platform.OS === "web" ? Fragment : ScrollView;
function Story({
documentation,
children,
noDarkMode
}) {
return /* @__PURE__ */ jsxs(ScrollWrapper, { children: [
documentation && /* @__PURE__ */ jsx(Surface, { accent: "info", className: "mb-xxl", children: documentation }),
["light", ...noDarkMode ? [] : ["dark"]].map(
(mode) => /* @__PURE__ */ jsx(ScopedTheme, { theme: mode, children: /* @__PURE__ */ jsx(View, { className: "bg-screen p-l", children }) }, mode)
)
] });
}
Story.Section = StorySection;
Story.SubSection = StorySubSection;
function StoryContainer({
title,
children
}) {
return /* @__PURE__ */ jsx(ScopedTheme, { theme: "light", children: /* @__PURE__ */ jsxs(ScrollView, { className: "bg-white p-3xl", children: [
/* @__PURE__ */ jsx(StoryTitle, { level: 1, children: title }),
children
] }) });
}
const StoryDecorator = (storyFn, { name, parameters }) => {
if (parameters?.container === false) return storyFn();
return /* @__PURE__ */ jsx(StoryContainer, { title: name, children: storyFn() });
};
const rowVariants = tv(
{
base: "flex-col",
variants: {
breakpoint: {
small: "sm:flex-row sm:mb-xl",
medium: "md:flex-row md:mb-xl"
},
flexWrap: { true: "" }
},
compoundVariants: [
{ breakpoint: "small", flexWrap: true, class: "sm:flex-wrap sm:gap-m" },
{ breakpoint: "medium", flexWrap: true, class: "md:flex-wrap md:gap-m" }
]
},
{ twMerge: false }
);
const itemVariants = tv(
{
base: "pt-m pb-xl",
variants: {
breakpoint: {
small: "sm:pt-0 sm:pb-0 sm:my-xxs shrink",
medium: "md:pt-0 md:pb-0 md:my-xxs shrink"
},
flexWrap: {
true: "",
false: ""
},
loose: {
true: "",
false: "grow"
}
},
compoundVariants: [
{ breakpoint: "small", flexWrap: false, class: "sm:basis-0" },
{ breakpoint: "medium", flexWrap: false, class: "md:basis-0" }
],
defaultVariants: {
flexWrap: false
}
},
{ twMerge: false }
);
function StoryGridRow({
children,
breakpoint = "small",
flexWrap,
loose
}) {
return /* @__PURE__ */ jsx(View, { className: rowVariants({ breakpoint, flexWrap }), children: Children.map(children, (child) => /* @__PURE__ */ jsx(View, { className: itemVariants({ breakpoint, flexWrap, loose }), children: child })) });
}
function StoryGridCol({
title,
children,
platform = "all"
}) {
const isNative = Platform.OS === "ios" || Platform.OS === "android";
if (Platform.OS === "web" && platform === "native") {
return null;
}
if (isNative && platform === "web") {
return null;
}
return title ? /* @__PURE__ */ jsxs(VStack, { children: [
/* @__PURE__ */ jsx(StoryTitle, { level: 4, numberOfLines: 1, children: title }),
children
] }) : children;
}
const StoryGrid = {
Row: StoryGridRow,
Col: StoryGridCol
};
function StableAccentScope({
mode: forcedMode,
accent,
children
}) {
const currentTheme = useCurrentTheme();
const currentMode = useCurrentMode();
return /* @__PURE__ */ jsx(
ScopedTheme,
{
theme: accent ? `${forcedMode ?? currentMode}_${accent}` : currentTheme,
children
}
);
}
function PortalAccentScope({
accent,
children
}) {
const inheritedTheme = useCurrentTheme();
const mode = useCurrentMode();
return /* @__PURE__ */ jsx(ScopedTheme, { theme: mode, children: /* @__PURE__ */ jsx(ScopedTheme, { theme: accent ? `${mode}_${accent}` : inheritedTheme, children }) });
}
function joinClasses(...classes) {
return classes.filter(Boolean).join(" ");
}
function usePresence(activeKey, exitDurationMs, children) {
const [exiting, setExiting] = useState([]);
const previousRef = useRef({ key: activeKey, node: children });
const childrenRef = useRef(children);
childrenRef.current = children;
const timersRef = useRef([]);
useEffect(
() => () => {
timersRef.current.forEach(clearTimeout);
},
[]
);
useEffect(() => {
const previous = previousRef.current;
if (previous.key === activeKey) {
return;
}
previousRef.current = { key: activeKey, node: childrenRef.current };
setExiting((list) => [...list, previous]);
const timer = setTimeout(() => {
setExiting((list) => list.filter((item) => item !== previous));
timersRef.current = timersRef.current.filter((t) => t !== timer);
}, exitDurationMs);
timersRef.current.push(timer);
}, [activeKey, exitDurationMs]);
return exiting;
}
function toItems(children) {
return Children.toArray(children).filter(isValidElement).map((child) => ({ key: child.key, node: child }));
}
function mergeKeys(previous, next) {
const nextSet = new Set(next);
const pendingByNext = /* @__PURE__ */ new Map();
let pending = [];
for (const key of previous) {
if (nextSet.has(key)) {
if (pending.length > 0) {
pendingByNext.set(key, pending);
pending = [];
}
} else {
pending.push(key);
}
}
const result = [];
for (const key of next) {
const before = pendingByNext.get(key);
if (before) {
result.push(...before);
}
result.push(key);
}
result.push(...pending);
return result;
}
function usePresenceList(children, exitDurationMs) {
const items = toItems(children);
const liveKeys = items.map((item) => item.key);
const signature = liveKeys.join("\0");
const nodesRef = useRef(/* @__PURE__ */ new Map());
for (const item of items) {
nodesRef.current.set(item.key, item.node);
}
const liveKeysRef = useRef(liveKeys);
liveKeysRef.current = liveKeys;
const [order, setOrder] = useState(liveKeys);
const orderRef = useRef(order);
orderRef.current = order;
const timersRef = useRef(/* @__PURE__ */ new Map());
useEffect(
() => () => {
timersRef.current.forEach(clearTimeout);
},
[]
);
useEffect(() => {
const live2 = new Set(liveKeysRef.current);
const newOrder = mergeKeys(orderRef.current, liveKeysRef.current);
for (const key of liveKeysRef.current) {
const timer = timersRef.current.get(key);
if (timer) {
clearTimeout(timer);
timersRef.current.delete(key);
}
}
for (const key of newOrder) {
if (!live2.has(key) && !timersRef.current.has(key)) {
const timer = setTimeout(() => {
timersRef.current.delete(key);
nodesRef.current.delete(key);
setOrder((current) => current.filter((k) => k !== key));
}, exitDurationMs);
timersRef.current.set(key, timer);
}
}
setOrder(newOrder);
}, [signature, exitDurationMs]);
const live = new Set(liveKeys);
return order.map((key) => ({
key,
node: nodesRef.current.get(key),
exiting: !live.has(key)
}));
}
function PresenceList({
exitDurationMs,
enterClassName,
exitClassName,
className,
children
}) {
const items = usePresenceList(children, exitDurationMs);
return /* @__PURE__ */ jsx(Fragment$1, { children: items.map((item) => /* @__PURE__ */ jsx(
View,
{
className: joinClasses(
className,
item.exiting ? exitClassName : enterClassName
),
children: item.node
},
item.key
)) });
}
function PresenceOne({
activeKey,
exitDurationMs,
enterClassName,
exitClassName,
className,
children
}) {
const exiting = usePresence(activeKey, exitDurationMs, children);
return /* @__PURE__ */ jsxs(Fragment$1, { children: [
exiting.map((item) => {
const node = item.node;
return cloneElement(node, {
key: item.key,
className: joinClasses(
node.props.className,
className,
exitClassName
)
});
}),
cloneElement(children, {
key: activeKey,
className: joinClasses(
children.props.className,
className,
enterClassName
)
})
] });
}
const animationDurationsMs = {
"slide": 600,
"collapse": 800,
"progress": 600,
"fade": 300,
"fast": 200
};
const scrollEndToleranceInPx = 1;
function useScrollEndState() {
const [isScrolledToEnd, setIsScrolledToEnd] = useState(true);
const viewportHeightRef = useRef(0);
const contentHeightRef = useRef(0);
const scrollOffsetRef = useRef(0);
const updateIsScrolledToEnd = () => {
setIsScrolledToEnd(
contentHeightRef.current - scrollOffsetRef.current <= viewportHeightRef.current + scrollEndToleranceInPx
);
};
return {
isScrolledToEnd,
scrollViewProps: {
scrollEventThrottle: 16,
onLayout: (event) => {
viewportHeightRef.current = event.nativeEvent.layout.height;
updateIsScrolledToEnd();
},
onContentSizeChange: (_width, height) => {
contentHeightRef.current = height;
updateIsScrolledToEnd();
},
onScroll: (event) => {
const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent;
scrollOffsetRef.current = contentOffset.y;
contentHeightRef.current = contentSize.height;
viewportHeightRef.current = layoutMeasurement.height;
updateIsScrolledToEnd();
}
}
};
}
function ExternalLink({
as: C,
href,
openLinkBehavior,
onPress,
...props
}) {
return /* @__PURE__ */ jsx(
C,
{
...props,
...href ? { href } : {},
...openLinkBehavior?.web === "targetSelf" ? {} : { hrefAttrs: { target: "_blank", rel: "noopener noreferrer" } },
onPress
}
);
}
const defaultExternalOpenLinkBehavior = {
native: "webBrowser",
web: "targetBlank"
};
function Icon({
icon,
size = 20,
className = "text-sharp"
}) {
return cloneElement(icon, {
// An <svg> is a flex item with the CSS default flex-shrink: 1, so a long
// sibling squeezes it below `size`. React Native already defaults to 0.
className: `shrink-0 ${className}`,
width: size,
height: size
});
}
function RingCircle({
center,
radius,
strokeWidth,
strokeDasharray,
strokeDashoffset,
className,
width,
height
}) {
const scale = 208 / (center * 2);
return /* @__PURE__ */ jsx(
"svg",
{
className,
width,
height,
viewBox: "0 0 256 256",
children: /* @__PURE__ */ jsx(
"circle",
{
cx: 128,
cy: 128,
r: radius * scale,
stroke: "currentColor",
strokeWidth: strokeWidth * scale,
strokeDasharray: strokeDasharray == null ? void 0 : strokeDasharray * scale,
strokeDashoffset: strokeDashoffset == null ? void 0 : strokeDashoffset * scale,
strokeLinecap: strokeDasharray == null ? void 0 : "round",
transform: strokeDasharray == null ? void 0 : "rotate(-90 128 128)",
className: strokeDasharray == null ? void 0 : "transition-[stroke-dashoffset] duration-progress ease-out",
fill: "none"
}
)
}
);
}
const startDelayMs = 100;
const stepIntervalMs = 500;
const completeDelayMs = 500;
const resetDelayMs = 1e3;
const indeterminateExitDurationMs = resetDelayMs + animationDurationsMs.fade;
const random = () => Math.ceil(Math.random() * 100) / 100;
function nextSimulatedProgress(progress) {
if (progress < 60) return progress + random() * 10 + 5;
if (progress < 70) return progress + random() * 10 + 3;
if (progress < 80) return progress + random() + 5;
if (progress < 90) return progress + random() + 1;
if (progress < 95) return progress + 0.1;
return progress;
}
function useSimulatedProgress(loading) {
const [progress, setProgress] = useState(1);
const [hidden, setHidden] = useState(!loading);
useEffect(() => {
if (!loading) return void 0;
setHidden(false);
const startTimer = setTimeout(() => {
setProgress(20);
}, startDelayMs);
const stepTimer = setInterval(() => {
setProgress(nextSimulatedProgress);
}, stepIntervalMs);
return () => {
clearTimeout(startTimer);
clearInterval(stepTimer);
};
}, [loading]);
useEffect(() => {
if (loading) return void 0;
const completeTimer = setTimeout(() => {
setProgress(100);
}, completeDelayMs);
const resetTimer = setTimeout(() => {
setHidden(true);
setProgress(1);
}, resetDelayMs);
return () => {
clearTimeout(completeTimer);
clearTimeout(resetTimer);
};
}, [loading]);
return { progress, hidden };
}
const diameterBySize = {
xs: 16,
sm: 32,
md: 64,
lg: 128
};
const strokeWidthBySize = {
xs: 2,
sm: 4,
md: 8,
lg: 16
};
const ring = tv({
base: "relative transition-opacity duration-fade",
variants: {
hidden: {
true: "opacity-0",
false: "opacity-100"
}
},
defaultVariants: { hidden: false }
});
function CircularProgress({
progress,
hidden = false,
accent = "brand",
size = "md"
}) {
const diameter = diameterBySize[size];
const strokeWidth = strokeWidthBySize[size];
const radius = (diameter - strokeWidth) / 2;
const circumference = 2 * Math.PI * radius;
const clampedProgress = Math.min(Math.max(progress, 0), 100);
const dashOffset = circumference * (1 - clampedProgress / 100);
const center = diameter / 2;
const trackRing = /* @__PURE__ */ jsx(RingCircle, { center, radius, strokeWidth });
const fillRing = /* @__PURE__ */ jsx(
RingCircle,
{
center,
radius,
strokeWidth,
strokeDasharray: circumference,
strokeDashoffset: dashOffset
}
);
return /* @__PURE__ */ jsx(AccentScope, { accent, children: /* @__PURE__ */ jsxs(
View,
{
className: ring({ hidden }),
style: { width: diameter, height: diameter },
children: [
/* @__PURE__ */ jsx(View, { className: "absolute inset-0", children: /* @__PURE__ */ jsx(
Icon,
{
icon: trackRing,
size: diameter,
className: "text-border-muted"
}
) }),
/* @__PURE__ */ jsx(View, { className: "absolute inset-0", children: /* @__PURE__ */ jsx(Icon, { icon: fillRing, size: diameter, className: "text-accent" }) })
]
}
) });
}
function IndeterminateCircularProgress({
loading,
accent,
size
}) {
const { progress, hidden } = useSimulatedProgress(loading);
return /* @__PURE__ */ jsx(
CircularProgress,
{
progress,
hidden,
accent,
size
}
);
}
const pressableBoxVariants = tv(
{
extend: interactiveBoxVariants,
base: "overflow-hidden",
variants: {
variant: {
contained: [
"rounded-sm",
process.env.EXPO_PUBLIC_STORYBOOK_ENABLED ? "" : "shadow-s bg-interactive-contained-pressable",
"hover:bg-interactive-contained-hover",
"focus:bg-interactive-contained-focus",
"active:bg-interactive-contained-active",
"disabled:bg-interactive-contained-disabled disabled:shadow-none",
"aria-disabled:bg-interactive-contained-disabled aria-disabled:shadow-none",
"focus-visible:outline-border-muted"
].join(" "),
outlined: [
"border bg-highlight",
process.env.EXPO_PUBLIC_STORYBOOK_ENABLED ? "" : "border-interactive-outlined-pressable",
"hover:border-interactive-outlined-hover",
"focus:border-interactive-outlined-focus",
"active:border-interactive-outlined-active",
"disabled:border-interactive-outlined-disabled",
"aria-disabled:border-interactive-outlined-disabled",
"focus-visible:outline-interactive-outlined-outline-focus"
].join(" "),
ghost: [
"border border-transparent",
"hover:border hover:border-interactive-outlined-hover",
"focus:border focus:border-interactive-outlined-focus",
"active:border active:border-interactive-outlined-active",
"disabled:border-interactive-outlined-disabled",
"aria-disabled:border-interactive-outlined-disabled",
"focus-visible:outline-interactive-outlined-outline-focus"
].join(" ")
},
forceStyle: {
hover: "",
focus: "",
press: "scale-[0.975]"
}
},
compoundVariants: process.env.EXPO_PUBLIC_STORYBOOK_ENABLED ? [
/* contained */
{
variant: "contained",
forceStyle: void 0,
ghost: false,
className: "shadow-s bg-interactive-contained-pressable"
},
{
variant: "contained",
forceStyle: "hover",
className: "shadow-s bg-interactive-contained-hover"
},
{
variant: "contained",
forceStyle: "focus",
className: "shadow-s bg-interactive-contained-focus"
},
{
variant: "contained",
forceStyle: "press",
className: "shadow-s bg-interactive-contained-active"
},
/* outlined */
{
variant: "outlined",
forceStyle: void 0,
ghost: false,
className: "border-interactive-outlined-pressable"
},
{
variant: "outlined",
forceStyle: "hover",
className: "border-interactive-outlined-hover"
},
{
variant: "outlined",
forceStyle: "focus",
className: "border-interactive-outlined-focus"
},
{
variant: "outlined",
forceStyle: "press",
className: "border-interactive-outlined-active"
},
/* ghost */
{
variant: "ghost",
forceStyle: void 0,
className: "border-transparent"
},
{
variant: "ghost",
forceStyle: "hover",
className: "border-interactive-outlined-hover"
},
{
variant: "ghost",
forceStyle: "focus",
className: "border-interactive-outlined-focus"
},
{
variant: "ghost",
forceStyle: "press",
className: "border-interactive-outlined-active"
}
] : void 0,
defaultVariants: {
variant: "contained"
}
},
{ twMerge: false }
);
const PressableBox = forwardRef(
({ className, variant, forceStyle, accent, ...props }, ref) => {
return /* @__PURE__ */ jsx(AccentScope, { accent, children: /* @__PURE__ */ jsx(
InteractiveBox,
{
ref,
withFocusVisibleOutline: true,
role: "button",
className: pressableBoxVariants({
variant,
className,
forceStyle
}),
...props
}
) });
}
);
const buttonHeight = {
sm: 38,
md: 44
};
const buttonVariants = tv(
{
slots: {
frame: "flex-row flex-center relative",
text: "font-body-bold text-center shrink transition-opacity duration-fade",
icon: "",
terminalIcon: "text-accent",
overlayIconContainer: "absolute inset-0 flex-center"
},
variants: {
size: {
sm: {
frame: "rounded-sm px-xs gap-xxs min-h-[38px]",
text: "text-sm py-xxs"
},
md: {
frame: "rounded-sm px-m gap-xs min-h-[44px]",
text: "text-base py-xs"
}
},
variant: {
contained: { text: "text-on-accent" },
outlined: { text: "text-sharp" },
ghost: { text: "text-sharp" }
},
disabled: { true: {}, false: {} },
dimmed: {
true: { text: "opacity-30", icon: "opacity-30" },
false: {}
}
},
compoundVariants: [
{
variant: "contained",
disabled: false,
ghost: false,
class: { icon: "text-on-accent" }
},
{
variant: "contained",
disabled: false,
ghost: true,
class: {
text: "text-sharp hover:text-on-accent",
icon: "text-sharp hover:text-on-accent"
}
},
{ variant: "outlined", disabled: false, class: { icon: "text-sharp" } },
{
variant: "contained",
disabled: true,
class: { icon: "text-disabled-sharp", text: "text-disabled-sharp" }
},
{
variant: "outlined",
disabled: true,
class: { icon: "text-disabled-muted", text: "text-disabled-muted" }
}
],
defaultVariants: { size: "md", variant: "contained" }
},
{ twMerge: false }
);
function resolveTerminalIcon(state) {
if (state === "success") {
return {
terminalIcon: /* @__PURE__ */ jsx(CheckCircleRegularIcon, {}),
terminalIconAccent: "success"
};
}
if (state === "failed") {
return {
terminalIcon: /* @__PURE__ */ jsx(WarningDuotoneIcon, {}),
terminalIconAccent: "danger"
};
}
return { terminalIcon: void 0, terminalIconAccent: void 0 };
}
function isButtonDisabled({
disabled,
state
}) {
return disabled === true || state != null;
}
function Button({
icon,
text,
disabled,
state,
accent = "brand",
variant = "contained",
size = "md",
className,
...pressableProps
}) {
const isLoading = state === "loading";
const [showSpinner, setShowSpinner] = useState(isLoading);
useEffect(() => {
if (isLoading) {
setShowSpinner(true);
return void 0;
}
const timer = setTimeout(() => {
setShowSpinner(false);
}, indeterminateExitDurationMs);
return () => {
clearTimeout(timer);
};
}, [isLoading]);
const { terminalIcon, terminalIconAccent } = resolveTerminalIcon(state);
const hasOverlayIcon = showSpinner || terminalIcon !== void 0;
const isDisabled = isButtonDisabled({ disabled, state });
const styles = buttonVariants({
size,
variant,
disabled: isDisabled,
dimmed: hasOverlayIcon
});
return /* @__PURE__ */ jsxs(
PressableBox,
{
accent,
variant,
disabled: isDisabled,
className: styles.frame({ className }),
...pressableProps,
children: [
hasOverlayIcon ? /* @__PURE__ */ jsx(View, { className: styles.overlayIconContainer(), children: showSpinner || !terminalIcon ? /* @__PURE__ */ jsx(
IndeterminateCircularProgress,
{
loading: isLoading,
accent,
size: size === "sm" ? "xs" : "sm"
}
) : /* @__PURE__ */ jsx(AccentScope, { accent: terminalIconAccent, children: /* @__PURE__ */ jsx(
Icon,
{
icon: terminalIcon,
className: styles.terminalIcon(),
size: size === "sm" ? 24 : 32
}
) }) }) : null,
icon ? /* @__PURE__ */ jsx(
Icon,
{
icon,
className: styles.icon(),
size: size === "sm" ? 16 : 20
}
) : null,
/* @__PURE__ */ jsx(Text, { "aria-disabled": isDisabled, className: styles.text(), children: text })
]
}
);
}
function ExternalLinkButton({
href,
openLinkBehavior = defaultExternalOpenLinkBehavior,
onPress,
...buttonProps
}) {
return /* @__PURE__ */ jsx(
ExternalLink,
{
as: Button,
href: isButtonDisabled(buttonProps) ? "" : href,
openLinkBehavior,
role: "link",
onPress: onPress ?? void 0,
...buttonProps
}
);
}
function InternalLinkButton({
href: _href,
...buttonProps
}) {
return /* @__PURE__ */ jsx(Button, { ...buttonProps, role: "link" });
}
const iconButtonVariants = tv(
{
slots: {
frame: "shrink-0 flex-center rounded-full",
icon: ""
},
variants: {
variant: {
contained: {},
outlined: {},
ghost: {}
},
disabled: {
true: {},
false: {}
}
},
compoundVariants: [
{
variant: "contained",
disabled: false,
class: { icon: "text-on-accent" }
},
{
variant: "outlined",
disabled: false,
class: { icon: "text-sharp" }
},
{
variant: "ghost",
disabled: false,
class: { icon: "text-sharp" }
},
{
variant: "contained",
disabled: true,
class: { icon: "text-disabled-sharp" }
},
{
variant: "outlined",
disabled: true,
class: { icon: "text-disabled-muted" }
},
{
variant: "ghost",
disabled: true,
class: { icon: "text-disabled-muted" }
}
],
defaultVariants: { variant: "contained" }
},
{ twMerge: false }
);
function IconButton({
icon,
disabled,
size = "md",
iconSize,
variant = "contained",
className,
...pressableProps
}) {
const diameter = typeof size === "number" ? size : buttonHeight[size];
const styles = iconButtonVariants({ variant, disabled: disabled === true });
return /* @__PURE__ */ jsx(
PressableBox,
{
variant,
disabled,
className: styles.frame({ className }),
style: { width: diameter, height: diameter },
...pressableProps,
children: /* @__PURE__ */ jsx(
Icon,
{
icon,
size: diameter * (iconSize === "fill" ? 0.8 : 0.55),
className: styles.icon()
}
)
}
);
}
const supportsStickyPosition = Platform.OS === "web";
const modalVariants = tv({
slots: {
// w-full so the panel shrinks on small screens (the backdrop padding keeps a
// margin); max-w caps it on wide viewports.
panel: "w-full max-h-full",
inset: "bg-highlight shadow-l",
header: "items-center gap-xs",
scrollContent: "",
// `sticky` pins it to the bottom of the scroll box on web. The border is
// transparent at rest so toggling it can't shift the layout.
footer: "items-center justify-end gap-m sticky bottom-0 bg-highlight border-t border-transparent"
},
variants: {
size: {
sm: {
panel: "max-w-[360px]",
inset: "rounded-sm p-xs",
header: "pl-xs",
scrollContent: "p-xs",
footer: "py-xs"
},
md: {
panel: "max-w-[520px]",
inset: "rounded-sm p-m",
header: "pl-m",
scrollContent: "p-m",
footer: "py-sm"
},
lg: {
panel: "max-w-[720px]",
inset: "rounded-md p-l",
header: "pl-l",
scrollContent: "p-l",
footer: "py-m"
}
},
withFooter: {
true: { scrollContent: "pb-0" }
},
// Native has no sticky positioning, so the footer sits below the scroll box
// instead of inside it — outside the scroll content container it has to
// carry that container's horizontal padding itself to stay aligned with the
// body.
detachedFooter: {
true: {}
},
// Only while the footer overlaps scrolled-past content does it need a rule
// separating it from the body; at the end of the scroll it sits in flow.
stuck: {
true: { footer: "border-border-muted" }
}
},
compoundVariants: [
{ size: "sm", detachedFooter: true, class: { footer: "px-xs" } },
{ size: "md", detachedFooter: true, class: { footer: "px-m" } },
{ size: "lg", detachedFooter: true, class: { footer: "px-l" } }
],
defaultVariants: { size: "md" }
});
function Modal({
visible,
onClose,
children,
icon,
footer,
accent,
size = "md",
title,
hideCloseButton = false,
closeButtonAriaLabel = "Close",
role = "dialog",
"aria-describedby": ariaDescribedby,
testID
}) {
const { height: windowHeight } = useWindowDimensions();
const titleId = useId();
const iconSize = size === "lg" ? "md" : size;
const { isScrolledToEnd, scrollViewProps } = useScrollEndState();
const styles = modalVariants({
size,
withFooter: footer !== void 0,
stuck: footer !== void 0 && !isScrolledToEnd,
detachedFooter: !supportsStickyPosition
});
const footerElement = footer === void 0 ? null : /* @__PURE__ */ jsx(HStack, { className: styles.footer(), children: footer });
return /* @__PURE__ */ jsx(
Modal$1,
{
transparent: true,
visible,
animationType: "fade",
onRequestClose: onClose,
children: /* @__PURE__ */ jsx(PortalAccentScope, { accent, children: /* @__PURE__ */ jsxs(View, { className: "flex-1 flex-center p-l", children: [
/* @__PURE__ */ jsx(
Pressable,
{
"aria-hidden": true,
focusable: false,
className: "absolute inset-0 bg-translucent",
onPress: onClose
}
),
/* @__PURE__ */ jsx(
View,
{
"aria-modal": true,
role,
"aria-labelledby": titleId,
"aria-describedby": ariaDescribedby,
testID,
className: styles.panel(),
children: /* @__PURE__ */ jsxs(View, { className: styles.inset(), children: [
/* @__PURE__ */ jsxs(
HStack,
{
className: styles.header(),
style: { minHeight: buttonHeight[iconSize] },
children: [
icon === void 0 ? null : /* @__PURE__ */ jsx(Icon, { icon, size: 24, className: "text-accent" }),
/* @__PURE__ */ jsx(
Text,
{
nativeID: titleId,
className: "shrink grow font-heading-bold text-xl leading-tight text-sharp",
children: title
}
),
hideCloseButton ? null : /* @__PURE__ */ jsx(
IconButton,
{
icon: /* @__PURE__ */ jsx(XRegularIcon, {}),
variant: "ghost",
size: iconSize,
"aria-label": closeButtonAriaLabel,
onPress: onClose
}
)
]
}
),
/* @__PURE__ */ jsxs(
ScrollView,
{
className: "shrink",
style: { maxHeight: windowHeight * 0.7 },
contentContainerClassName: styles.scrollContent(),
...scrollViewProps,
children: [
children,
supportsStickyPosition ? footerElement : null
]
}
),
supportsStickyPosition ? null : footerElement
] })
}
)
] }) })
}
);
}
const messageFrameVariants = tv(
{
base: "flex-row items-center overflow-hidden bg-highlight-accent",
variants: {
size: {
sm: "gap-xs p-sm rounded-xs",
md: "gap-m p-m rounded-sm",
lg: "gap-l p-l rounded-md"
},
variant: {
// Raised: the banner is its own layer above the screen background.
surface: "shadow-m",
// Flush: for a banner already inside a raised surface, where a second
// elevation would read as a card stacked on a card.
flat: "shadow-none border-border-muted border"
}
},
defaultVariants: { size: "md", variant: "surface" }
},
{ twMerge: false }
);
const ICON_SIZE$1 = { sm: 20, md: 24, lg: 28 };
const DISMISS_BUTTON_SIZE = {
sm: 24,
md: 40,
lg: 40
};
function Message({
icon,
size = "md",
variant,
accent,
children,
onDismiss,
dismissIconAriaLabel
}) {
const dismissDiameter = DISMISS_BUTTON_SIZE[size];
return /* @__PURE__ */ jsx(AccentScope, { accent, children: /* @__PURE__ */ jsxs(Box, { className: messageFrameVariants({ size, variant }), children: [
/* @__PURE__ */ jsx(Icon, { icon, size: ICON_SIZE$1[size], className: "text-accent" }),
/* @__PURE__ */ jsx(Text, { className: "text-sharp shrink grow", children }),
onDismiss ? /* @__PURE__ */ jsx(
Box,
{
style: { width: dismissDiameter, height: dismissDiameter },
className: "shrink-0 flex-center",
children: /* @__PURE__ */ jsx(
IconButton,
{
icon: /* @__PURE__ */ jsx(XRegularIcon, {}),
iconSize: size === "sm" ? "fill" : void 0,
size: dismissDiameter,
variant: "ghost",
"aria-label": dismissIconAriaLabel,
onPress: onDismiss
}
)
}
) : null
] }) });
}
function InfoMessage(props) {
return /* @__PURE__ */ jsx(Message, { ...props, accent: "info", icon: /* @__PURE__ */ jsx(InfoRegularIcon, {}) });
}
function ConfirmationMessage(props) {
return /* @__PURE__ */ jsx(Message, { ...props, accent: "success", icon: /* @__PURE__ */ jsx(CheckRegularIcon, {}) });
}
function WarningMessage(props) {
return /* @__PURE__ */ jsx(Message, { ...props, accent: "warning", icon: /* @__PURE__ */ jsx(WarningRegularIcon, {}) });
}
function ErrorMessage(props) {
return /* @__PURE__ */ jsx(Message, { ...props, accent: "danger", icon: /* @__PURE__ */ jsx(WarningDuotoneIcon, {}) });
}
function CollapsibleErrorMessage({
error,
errorToMessage,
variant
}) {
return /* @__PURE__ */ jsx(
View,
{
role: "alert",
className: `overflow-hidden transition-[height,opacity] duration-collapse ${error ? "p-sm h-auto opacity-100" : "absolute h-0 opacity-0"}`,
children: error === null ? null : /* @__PURE__ */ jsx(ErrorMessage, { size: "sm", variant, children: errorToMessage(error) })
}
);
}
const settledDisplayDurationMs = 4e3;
const idleState = { buttonState: void 0, error: null };
function pressAsyncReducer(previousState, action) {
switch (action.type) {
case "start":
return { buttonState: "loading", error: null };
case "resolve":
return { buttonState: "success", error: null };
case "reject":
return { buttonState: "failed", error: action.error };
case "settledTimeout":
return { buttonState: void 0, error: previousState.error };
default:
throw new Error(`Unhandled action: ${JSON.stringify(action)}`);
}
}
function usePressAsync(onPress) {
const [pressAsyncState, dispatch] = useReducer(pressAsyncReducer, idleState);
const settledTimerRef = useRef(void 0);
useEffect(() => {
return () => {
clearTimeout(settledTimerRef.current);
};
}, []);
function handlePress(event) {
if (pressAsyncState.buttonState === "loading") return;
clearTimeout(settledTimerRef.current);
const result = onPress(event);
if (!(result instanceof Promise)) return;
dispatch({ type: "start" });
function scheduleSettledTimeout() {
settledTimerRef.current = setTimeout(() => {
dispatch({ type: "settledTimeout" });
}, settledDisplayDurationMs);
}
result.then(() => {
dispatch({ type: "resolve" });
scheduleSettledTimeout();
}).catch((caughtError) => {
const normalizedError = caughtError instanceof Error ? caughtError : new Error(String(caughtError));
console.error(
"Unexpected error caught in usePressAsync",
normalizedError
);
dispatch({ type: "reject", error: normalizedError });
scheduleSettledTimeout();
});
}
return { ...pressAsyncState, handlePress };
}
function noop() {
}
function ActionFooter({
children,
errorToMessage,
error
}) {
const errorMessage = errorToMessage === void 0 ? null : (
// The dialog panel is already a raised surface, so the message is flat.
/* @__PURE__ */ jsx(
CollapsibleErrorMessage,
{
error,
errorToMessage,
variant: "flat"
}
)
);
return /* @__PURE__ */ jsxs(VStack, { className: "w-full gap-sm", children: [
/* @__PURE__ */ jsx(HStack, { className: "items-center justify-end gap-m", children }),
errorMessage
] });
}
function resolveVariant(props, {
accent,
buttonState,
error,
isPending,
handleConfirm
}) {
switch (props.variant) {
case "alert": {
const { onClose, closeText } = props;
return {
onDismiss: onClose,
footer: /* @__PURE__ */ jsx(Button, { accent, text: closeText ?? "OK", onPress: onClose })
};
}
case "required": {
const { confirmText, confirmDisabled, errorToMessage } = props;
return {
// Non-dismissible: only the explicit action closes it.
onDismiss: noop,
footer: /* @__PURE__ */ jsx(ActionFooter, { error, errorToMessage, children: /* @__PURE__ */ jsx(
Button,
{
accent,
text: confirmText ?? "OK",
state: buttonState,
disabled: confirmDisabled,
onPress: handleConfirm
}
) })
};
}
case "confirm":
case void 0:
default: {
const {
onCancel,
confirmText,
cancelText,
confirmDisabled,
errorToMessage
} = props;
return {
onDismiss: isPending ? noop : onCancel,
footer: /* @__PURE__ */ jsxs(ActionFooter, { error, errorToMessage, children: [
/* @__PURE__ */ jsx(
Button,
{
variant: "outlined",
text: cancelText ?? "Cancel",
disabled: isPending,
onPress: onCancel
}
),
/* @__PURE__ */ jsx(
Button,
{
accent,
text: confirmText ?? "Confirm",
state: buttonState,
disabled: confirmDisabled,
onPress: handleConfirm
}
)
] })
};
}
}
}
function resolveConfirmHandler(props) {
return props.variant === "alert" ? noop : props.onConfirm;
}
function AlertDialog(props) {
const {
visible,
title,
children,
accent = "danger",
icon,
size = "md",
testID
} = props;
const descriptionId = useId();
const { buttonState, error, handlePress } = usePressAsync(
resolveConfirmHandler(props)
);
const isPending = buttonState === "loading";
const { footer, onDismiss } = resolveVariant(props, {
accent,
buttonState,
error,
isPending,
handleConfirm: handlePress
});
return /* @__PURE__ */ jsx(
Modal,
{
hideCloseButton: true,