panelui-native 0.97.0 → 0.99.0

package/lib/typescript/src/components/image-viewer/image-viewer-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-viewer-geometry.d.ts","sourceRoot":"","sources":["../../../../../src/components/image-viewer/image-viewer-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,IAAK,SAAQ,IAAI;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,kEAAkE;AAClE,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAQ9D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,CASvD;AAED,oEAAoE;AACpE,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,CAItD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI,CAOxD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAK7F;AAED,yFAAyF;AACzF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAOR;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGhF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,MAAM,CAIR;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,MAAM,CAMR;AAED,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAK5E;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAInE;AAED,iFAAiF;AACjF,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIpE;AAED,uFAAuF;AACvF,wBAAgB,QAAQ,CACtB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,OAAO,CAQT"}

package/lib/typescript/src/components/image-viewer/index.d.ts

@@ -0,0 +1,148 @@
+/**
+ * ImageViewer — a picture that opens out of the page to fill the screen.
+ *
+ * Pressing a trigger lifts its image from where it sits, grows it to the whole
+ * picture in the middle of the screen, and blurs the page behind it. From there
+ * it can be pinched and double-tapped to zoom, swiped sideways to the next
+ * image under the same root, and dragged away to put it back.
+ *
+ * ```tsx
+ * <ImageViewer>
+ *   {photos.map((photo) => (
+ *     <ImageViewer.Trigger
+ *       key={photo.id}
+ *       source={photo.source}
+ *       alt={photo.alt}
+ *       radius={12}
+ *       className="h-40 flex-1 rounded-xl"
+ *     />
+ *   ))}
+ * </ImageViewer>
+ * ```
+ *
+ * ## The image travels; nothing appears
+ *
+ * The viewer never fades a second copy of the picture in over the first. The
+ * thumbnail is hidden and the same image is drawn in a frame that starts at the
+ * thumbnail's exact rectangle and corner radius and ends at the fitted one. The
+ * picture inside that frame is always drawn at the size that *covers* it, so the
+ * crop a thumbnail shows opens out into the whole image as the frame grows — and
+ * closes back into the crop on the way home. That continuity is the point: the
+ * picture on screen is the one that was pressed, not a picture of it.
+ *
+ * The frame animates its bounds rather than a transform, because a transform
+ * cannot change a crop. It is one view with one child, so the layout pass it
+ * costs per frame is small.
+ *
+ * ## Every trigger under one root is a page
+ *
+ * Triggers register themselves with the root as they mount, in render order or
+ * by an explicit `index`. Opening one opens the gallery at its page, and the
+ * thumbnail hidden underneath follows the page — close on the third image and it
+ * flies back into the third thumbnail.
+ *
+ * ## One gesture surface, decided at the start
+ *
+ * Pinching, panning a zoomed image, turning the page and dragging to dismiss all
+ * begin as a one- or two-finger drag, and which one it is gets decided the
+ * moment it starts: two fingers zoom, one finger on a zoomed image pans it, one
+ * finger moving sideways across a gallery turns the page, and anything else
+ * drags the image away. Deciding once keeps a drag from changing its mind
+ * halfway, which is what makes a viewer feel loose.
+ */
+import { type ReactNode } from 'react';
+import { type ImageSourcePropType, type PressableProps } from 'react-native';
+export interface ImageViewerProps {
+    children?: ReactNode;
+    /** Controlled open state. */
+    open?: boolean;
+    /** Initial open state when uncontrolled. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled page — which trigger's image is showing, in page order. */
+    index?: number;
+    /** Initial page when uncontrolled. */
+    defaultIndex?: number;
+    onIndexChange?: (index: number) => void;
+    /**
+     * Blur the page behind the picture. Needs the optional `expo-blur`, and dims
+     * instead without it. Reduce Transparency draws an opaque backdrop.
+     */
+    blur?: boolean;
+    /** How far a pinch can zoom in, as a multiple of the fitted size. */
+    maxScale?: number;
+    /** Where a double tap zooms to, as a multiple of the fitted size. */
+    doubleTapScale?: number;
+    /** Tick as a drag to dismiss begins. Needs the optional `expo-haptics`. */
+    haptics?: boolean;
+    /** Draw the close button. Tapping outside the picture and dragging it away still close it. */
+    showClose?: boolean;
+    /** Read out for the close button. */
+    closeLabel?: string;
+    /**
+     * Space kept between the open picture and the edges of the screen, in points.
+     * Measured from the safe area at the top and bottom, and the larger of the
+     * two is used for both, so the picture stays centred. `0` fills the screen.
+     */
+    inset?: number;
+    /**
+     * Corner radius of the open picture, in points. The corners stay this size on
+     * screen while the picture is zoomed or dragged. `0` squares them.
+     */
+    cornerRadius?: number;
+}
+declare function ImageViewerRoot({ children, open, defaultOpen, onOpenChange, index, defaultIndex, onIndexChange, blur, maxScale, doubleTapScale, haptics, showClose, closeLabel, inset, cornerRadius, }: ImageViewerProps): import("react").JSX.Element;
+export interface ImageViewerTriggerProps extends Omit<PressableProps, 'children' | 'style' | 'disabled'> {
+    /**
+     * Classes on the pressable. Without `children` the image fills it, so give it
+     * a size — `h-48 w-full`, `aspect-square flex-1`.
+     */
+    className?: string;
+    /** The picture. Shown in the page and, until `fullSource` loads, in the viewer. */
+    source: ImageSourcePropType;
+    /**
+     * A larger copy to show once the viewer is open. It loads when the viewer
+     * opens and replaces `source` when it arrives, so a feed can carry thumbnails.
+     */
+    fullSource?: ImageSourcePropType;
+    /** Described for a screen reader, on the trigger and in the viewer. */
+    alt?: string;
+    /** Shown under the picture while it is open. A string is set as text. */
+    caption?: ReactNode;
+    /** Page order within the root. Render order when left out. */
+    index?: number;
+    /**
+     * The corner radius the picture has in the page, in points, so the flight
+     * starts from the same shape. Match it to the `rounded-*` class you gave the
+     * trigger — a class cannot be read back.
+     */
+    radius?: number;
+    /**
+     * The image's own width and height, when known. Saves looking it up, and is
+     * the only way the viewer knows the proportions before a remote image loads.
+     */
+    width?: number;
+    height?: number;
+    /** Nothing opens, and the press is not reported. */
+    disabled?: boolean;
+    /**
+     * Draw the picture yourself — a `Post.Media`, a card. It should show `source`
+     * cropped to fill, the way the viewer's own flight starts. Left out, the
+     * trigger draws `source` to fill its box.
+     */
+    children?: ReactNode;
+}
+/**
+ * The thing pressed to open the viewer.
+ *
+ * It registers its picture with the root, so the gallery is simply every
+ * trigger under that root. While its picture is out on the screen it is drawn
+ * transparent — not removed, so the page does not reflow under the blur and the
+ * flight home has somewhere to land.
+ */
+declare function ImageViewerTrigger({ className, source, fullSource, alt, caption, index, radius, width, height, disabled, children, onPress, onLayout, ...props }: ImageViewerTriggerProps): import("react").JSX.Element;
+export declare const ImageViewer: typeof ImageViewerRoot & {
+    Trigger: typeof ImageViewerTrigger;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/image-viewer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/image-viewer/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,OAAO,EAWL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAOL,KAAK,mBAAmB,EAExB,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAyKtB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,6BAA6B;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8FAA8F;IAC9F,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,iBAAS,eAAe,CAAC,EACvB,QAAQ,EACR,IAAI,EACJ,WAAmB,EACnB,YAAY,EACZ,KAAK,EACL,YAAgB,EAChB,aAAa,EACb,IAAW,EACX,QAAY,EACZ,cAAoB,EACpB,OAAc,EACd,SAAgB,EAChB,UAAoB,EACpB,KAAqB,EACrB,YAAoC,GACrC,EAAE,gBAAgB,+BAuElB;AAMD,MAAM,WAAW,uBACf,SAAQ,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC;IAC/D;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mFAAmF;IACnF,MAAM,EAAE,mBAAmB,CAAC;IAC5B;;;OAGG;IACH,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC,uEAAuE;IACvE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAmBD;;;;;;;GAOG;AACH,iBAAS,kBAAkB,CAAC,EAC1B,SAAS,EACT,MAAM,EACN,UAAU,EACV,GAAG,EACH,OAAO,EACP,KAAK,EACL,MAAU,EACV,KAAK,EACL,MAAM,EACN,QAAgB,EAChB,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,uBAAuB,+BAyGzB;AA0vBD,eAAO,MAAM,WAAW;;CAEtB,CAAC"}

package/lib/typescript/src/components/stack-card/index.d.ts

@@ -0,0 +1,472 @@
+/**
+ * StackCard — a pile of cards, taken one at a time by throwing the top one off.
+ *
+ * ```tsx
+ * <StackCard className="h-[460px]" onSwipe={(direction, index) => decide(people[index], direction)}>
+ *   <StackCard.Stamp direction="right" color="success">Yes</StackCard.Stamp>
+ *   <StackCard.Stamp direction="left" color="destructive">No</StackCard.Stamp>
+ *   {people.map((person) => (
+ *     <StackCard.Card key={person.id}>
+ *       <Text>{person.name}</Text>
+ *     </StackCard.Card>
+ *   ))}
+ *   <StackCard.Empty>
+ *     <Text muted>Nobody left</Text>
+ *   </StackCard.Empty>
+ * </StackCard>
+ * ```
+ *
+ * For a queue of things each answered with one decision and then gone: a
+ * review queue, a set of flashcards, an inbox of suggestions. The gesture is
+ * the answer, which is what makes it quicker than a list of rows with buttons
+ * on them — and what makes it wrong for anything the reader has to compare,
+ * skim or come back to. A deck shows one card and hides the rest.
+ *
+ * For a run of slides the reader browses rather than disposes of, use
+ * [Carousel](../carousel); for one row's actions in a list, [Swipe](../swipe).
+ *
+ * ## The pile is one drag, read by everything
+ *
+ * The top card's `x` and `y` are the only values a gesture writes, and every
+ * other moving part is derived from them: each stamp fades in on how far the
+ * drag has carried the card toward its own direction, and the cards behind
+ * climb toward the top position on the furthest of those.
+ *
+ * That derivation is also what makes a dismissal seamless. By the time the top
+ * card has been carried far enough to leave, the second card is already
+ * exactly where the top card sits — so when the deck advances there is nothing
+ * left for it to move, and no frame in which the pile re-arranges itself.
+ *
+ * ## The deck moves on the UI thread, and React catches up
+ *
+ * Which card is on top is held twice: as React state, for what is mounted and
+ * for the callbacks, and as a shared value, for what is drawn. A throw is
+ * handled entirely on the UI thread — the card leaves on the frame the finger
+ * lets go, and once it is off the screen the top card, the offset and the fade
+ * all move in one step — and only then is the new index requested from React.
+ *
+ * Nothing on the screen waits for a render, so a busy JavaScript thread cannot
+ * stall a throw or leave a frame where the two halves disagree. What React
+ * renders afterwards is kept from showing before the UI thread agrees with it:
+ * a stamp is only drawn on the card the UI thread has on top.
+ *
+ * A controlled deck is still the owner's to decide. An owner that declines the
+ * new index gets the card back, flown in from the way it went; one that
+ * accepts it sees nothing move at all, because it already has.
+ *
+ * One card behind the pile's stated depth stays mounted so it can fade in as
+ * it takes the last visible place, and one card ahead of the top stays mounted
+ * so `undo` has something to fly back in. The rest are unmounted, which is
+ * what makes a deck of five hundred cost what a deck of five costs.
+ *
+ * ## A deck is not reachable by a gesture alone
+ *
+ * A throw is not available to a screen reader, and neither is a card that can
+ * only be answered by throwing it. So the top card publishes an accessibility
+ * action for every direction the deck accepts, and `StackCard.Action` renders
+ * the same decisions as ordinary buttons — which sighted people reach for too,
+ * on the card they are not sure about.
+ */
+import { type ReactNode } from 'react';
+import { View, type ViewProps } from 'react-native';
+import { type SharedValue } from 'react-native-reanimated';
+import { type VariantProps } from 'tailwind-variants';
+import { type StackCardDirection } from './stack-card-geometry.js';
+export type { StackCardDirection } from './stack-card-geometry.js';
+/**
+ * The deck's state, for a control that lives outside the pile — a counter, a
+ * progress bar, a button in a toolbar.
+ *
+ * `release` is a shared value running 0 to 1 as the top card is carried toward
+ * leaving, so something beside the deck can move with the drag rather than
+ * starting a second animation next to it.
+ */
+export declare function useStackCard(): {
+    /** How many cards have been answered, which is also the top card's index. */
+    index: number;
+    /** How many cards the deck was given. */
+    count: number;
+    /** How many are left, the top one included. */
+    remaining: number;
+    /** Whether there is a card to bring back. */
+    canUndo: boolean;
+    release: SharedValue<number>;
+    send: (direction: StackCardDirection) => void;
+    undo: () => void;
+    reset: () => void;
+};
+/** How the cards behind the top one are arranged. */
+export type StackCardLayout = 'stack' | 'fan' | 'flat';
+export interface StackCardHandle {
+    /** Send the top card away as though it had been thrown that way. */
+    swipe: (direction: StackCardDirection) => void;
+    /** Bring the last card back, and with it the decision that removed it. */
+    undo: () => void;
+    /** Put every card back. */
+    reset: () => void;
+}
+export interface StackCardProps extends Omit<ViewProps, 'children'> {
+    /**
+     * A `StackCard.Card` for each card, plus any of `StackCard.Stamp`,
+     * `StackCard.Empty` and `StackCard.Actions`, in any order. Anything else is
+     * laid out under the pile.
+     */
+    children?: ReactNode;
+    /**
+     * Which card is on top, when the caller holds it. Leave unset to let the
+     * deck keep its own. A controlled deck that declines a request stays where
+     * it is and the thrown card comes back, so this is also how a decision is
+     * confirmed before it is taken.
+     */
+    index?: number;
+    /** Which card an uncontrolled deck starts on. */
+    defaultIndex?: number;
+    /** Fires whenever the deck asks to move, with the index it is asking for. */
+    onIndexChange?: (index: number) => void;
+    /**
+     * Fires when a card leaves, with the way it went and the index it was at.
+     * It fires before `onIndexChange` asks for the next index. Not called by
+     * `undo` — the index going back is what reports that.
+     */
+    onSwipe?: (direction: StackCardDirection, index: number) => void;
+    /** Fires once when the last card leaves. */
+    onEmpty?: () => void;
+    /**
+     * Which ways a card may be thrown. Left and right by default.
+     *
+     * A direction left out still follows the finger a little and then comes
+     * back, rather than refusing to move at all — a card that does not budge
+     * reads as a frozen screen.
+     */
+    directions?: readonly StackCardDirection[];
+    /**
+     * How the cards behind the top one are arranged. `stack` steps them down and
+     * back; `fan` turns them alternately, like a hand of cards; `flat` hides them
+     * entirely, for full-bleed cards where a peeking edge is only clutter.
+     */
+    layout?: StackCardLayout;
+    /** How many cards are drawn behind the top one. Two is a pile; five is a mess. */
+    depth?: number;
+    /**
+     * How far a card has to be taken for a release to send it away, as a
+     * fraction of the card. Momentum counts toward it, so a flick clears it
+     * without travelling.
+     */
+    threshold?: number;
+    /** Stop the deck taking a gesture, without changing how it looks. */
+    disabled?: boolean;
+    /** A tick when a drag first reaches the point of no return, and a knock as the card goes. */
+    haptics?: boolean;
+    /**
+     * What a screen reader is offered for each direction, in place of "Swipe
+     * left". Name the decision — `{ left: 'Skip', right: 'Save' }`.
+     */
+    directionLabels?: Partial<Record<StackCardDirection, string>>;
+    /** Classes for the whole control. Give it a height; the pile fills what is left. */
+    className?: string;
+    /** Classes for the box the cards are laid out in. */
+    pileClassName?: string;
+}
+export interface StackCardCardProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+}
+/**
+ * A stamp is a filled block of colour with a word on it, turned a few degrees
+ * so it reads as pressed onto the card rather than laid out on it.
+ *
+ * The fill is the status colour at full strength rather than a tint of it: a
+ * stamp exists only for the moment it appears, and a six-per-cent wash of the
+ * card's own surface is a smudge rather than an answer. The word is carried in
+ * white, which is what the status colours are chosen to take — a status's
+ * `-foreground` token is its darker text form, meant for a neutral surface,
+ * and over the fill it is the same hue twice.
+ *
+ * It sits in the corner the card is being pulled away from, which is also the
+ * corner the thumb is not over.
+ */
+declare const stampVariants: import("tailwind-variants").TVReturnType<{
+    color: {
+        default: {
+            pill: string;
+            label: string;
+        };
+        primary: {
+            pill: string;
+            label: string;
+        };
+        success: {
+            pill: string;
+            label: string;
+        };
+        warning: {
+            pill: string;
+            label: string;
+        };
+        info: {
+            pill: string;
+            label: string;
+        };
+        destructive: {
+            pill: string;
+            label: string;
+        };
+    };
+    direction: {
+        left: {
+            root: string;
+            pill: string;
+        };
+        right: {
+            root: string;
+            pill: string;
+        };
+        up: {
+            root: string;
+        };
+        down: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    pill: string;
+    label: string;
+}, undefined, {
+    color: {
+        default: {
+            pill: string;
+            label: string;
+        };
+        primary: {
+            pill: string;
+            label: string;
+        };
+        success: {
+            pill: string;
+            label: string;
+        };
+        warning: {
+            pill: string;
+            label: string;
+        };
+        info: {
+            pill: string;
+            label: string;
+        };
+        destructive: {
+            pill: string;
+            label: string;
+        };
+    };
+    direction: {
+        left: {
+            root: string;
+            pill: string;
+        };
+        right: {
+            root: string;
+            pill: string;
+        };
+        up: {
+            root: string;
+        };
+        down: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    pill: string;
+    label: string;
+}, import("tailwind-variants").TVReturnType<{
+    color: {
+        default: {
+            pill: string;
+            label: string;
+        };
+        primary: {
+            pill: string;
+            label: string;
+        };
+        success: {
+            pill: string;
+            label: string;
+        };
+        warning: {
+            pill: string;
+            label: string;
+        };
+        info: {
+            pill: string;
+            label: string;
+        };
+        destructive: {
+            pill: string;
+            label: string;
+        };
+    };
+    direction: {
+        left: {
+            root: string;
+            pill: string;
+        };
+        right: {
+            root: string;
+            pill: string;
+        };
+        up: {
+            root: string;
+        };
+        down: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    pill: string;
+    label: string;
+}, undefined, unknown, unknown, undefined>>;
+export type StackCardStampColor = 'default' | 'primary' | 'success' | 'warning' | 'info' | 'destructive';
+export interface StackCardStampProps extends Omit<ViewProps, 'children'>, VariantProps<typeof stampVariants> {
+    className?: string;
+    /** The word, or anything else to draw on the stamp. */
+    children?: ReactNode;
+    /** Which direction the stamp answers for. Also where on the card it goes. */
+    direction?: StackCardDirection;
+    /** Extra classes for the label, when the stamp is given a string. */
+    labelClassName?: string;
+}
+export interface StackCardEmptyProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+}
+export interface StackCardActionsProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+}
+declare const actionVariants: import("tailwind-variants").TVReturnType<{
+    color: {
+        default: {
+            root: string;
+        };
+        primary: {
+            root: string;
+        };
+        success: {
+            root: string;
+        };
+        warning: {
+            root: string;
+        };
+        info: {
+            root: string;
+        };
+        destructive: {
+            root: string;
+        };
+    };
+    size: {
+        sm: {
+            root: string;
+        };
+        md: {
+            root: string;
+        };
+        lg: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+}, undefined, {
+    color: {
+        default: {
+            root: string;
+        };
+        primary: {
+            root: string;
+        };
+        success: {
+            root: string;
+        };
+        warning: {
+            root: string;
+        };
+        info: {
+            root: string;
+        };
+        destructive: {
+            root: string;
+        };
+    };
+    size: {
+        sm: {
+            root: string;
+        };
+        md: {
+            root: string;
+        };
+        lg: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+}, import("tailwind-variants").TVReturnType<{
+    color: {
+        default: {
+            root: string;
+        };
+        primary: {
+            root: string;
+        };
+        success: {
+            root: string;
+        };
+        warning: {
+            root: string;
+        };
+        info: {
+            root: string;
+        };
+        destructive: {
+            root: string;
+        };
+    };
+    size: {
+        sm: {
+            root: string;
+        };
+        md: {
+            root: string;
+        };
+        lg: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+}, undefined, unknown, unknown, undefined>>;
+export interface StackCardActionProps extends Omit<ViewProps, 'children'>, VariantProps<typeof actionVariants> {
+    className?: string;
+    /** What pressing it does: send the top card that way, or bring the last one back. */
+    action: StackCardDirection | 'undo';
+    /** The glyph. Sized and tinted by the button — pass neither. */
+    icon?: ReactNode;
+    /**
+     * What a screen reader is offered. Falls back to "Undo", or to the plain
+     * name of the direction.
+     */
+    label?: string;
+    /** Run after the deck has been told, for a sound or a log. */
+    onPress?: () => void;
+}
+export declare const StackCard: import("react").ForwardRefExoticComponent<StackCardProps & import("react").RefAttributes<StackCardHandle>> & {
+    Card: import("react").ForwardRefExoticComponent<StackCardCardProps & import("react").RefAttributes<View>>;
+    Stamp: import("react").ForwardRefExoticComponent<StackCardStampProps & import("react").RefAttributes<View>>;
+    Empty: import("react").ForwardRefExoticComponent<StackCardEmptyProps & import("react").RefAttributes<View>>;
+    Actions: import("react").ForwardRefExoticComponent<StackCardActionsProps & import("react").RefAttributes<View>>;
+    Action: import("react").ForwardRefExoticComponent<StackCardActionProps & import("react").RefAttributes<View>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/stack-card/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/stack-card/index.tsx"],"names":[],"mappings":"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"}