@rockerone/xprnkit 0.3.0

package/build/components/swap/xprn-swap-provider.js

@@ -0,0 +1,187 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useCallback, useContext, useEffect, useMemo, useState, } from "react";
+import { getSwapMarkets } from "./xprn-swap-markets";
+import { useXPRN } from "../../providers/XPRNProvider";
+const XPRNSwapContext = React.createContext({
+    marketProviders: [],
+    currentMarketProvider: null,
+    setCurrentMarketProvider: (marketProvider) => { },
+    refreshMarketPairs: () => { },
+    currentMarketPairs: [],
+    refreshStatus: "idle",
+    setCurrentSwapPair: pair => { },
+    currentSwapPair: null,
+    currentSwapValues: null,
+    setCurrentSwapValues: (value) => { },
+    swapTransaction: [],
+    swapVolume: 0,
+    setSwapSide: (value) => { },
+    swapSide: "buy",
+    setSwapVolume: (value) => { },
+    swapValues: { base: 0, quote: 0, volume: 0, lastMutated: "base" },
+    updateSwapValues: (base, quote, lastMutated) => { },
+});
+export const XPRNSwapProvider = ({ children, config, }) => {
+    const [services, setServices] = useState();
+    const [currentMarketProvider, setCurrentMarketProvider] = useState();
+    const [currentMarketPairs, setCurrentMarketPairs] = useState();
+    const [refreshStatus, setRefreshStatus] = useState();
+    const [currentSwapPair, setCurrentSwapPair] = useState();
+    const [swapTransaction, setSwapTransaction] = useState();
+    const [swapSide, setSwapSide] = useState();
+    const [swapVolume, setSwapVolume] = useState();
+    const [swapValues, setSwapValues] = useState();
+    const { session } = useXPRN();
+    const refreshMarketPairs = useCallback(() => {
+        if (!currentMarketProvider)
+            return;
+        setRefreshStatus("pending");
+        fetch(currentMarketProvider.endpoint)
+            .then(async (res) => {
+            return await res.json();
+        })
+            .then(res => {
+            let parsedPairs = currentMarketProvider.parse(res);
+            if (config && config.filters) {
+                if (config.filters.baseSymbol)
+                    parsedPairs = parsedPairs.filter(pair => {
+                        if (!config.filters)
+                            return false;
+                        return pair.baseToken == config.filters.baseSymbol;
+                    });
+                if (config.filters.quoteSymbol)
+                    parsedPairs = parsedPairs.filter(pair => {
+                        if (!config.filters)
+                            return false;
+                        return pair.quoteToken == config.filters.quoteSymbol;
+                    });
+            }
+            setCurrentMarketPairs(parsedPairs);
+            setRefreshStatus("idle");
+        })
+            .catch(() => {
+            setRefreshStatus("fail");
+        });
+    }, [currentMarketProvider, setRefreshStatus, setCurrentMarketPairs, config]);
+    const defaultServices = useMemo(() => {
+        const marketFilters = config ? config.marketFilters : undefined;
+        return getSwapMarkets(marketFilters);
+    }, []);
+    const defaultService = useMemo(() => {
+        let foundService = defaultServices.findLast(service => {
+            return service.default;
+        });
+        if (foundService)
+            return foundService;
+        return defaultServices[0];
+    }, [services, defaultServices]);
+    const updateSwapValues = useCallback((base, quote, lastMutated) => {
+        if (!currentSwapPair)
+            return;
+        const validatedBase = base ?? 0;
+        const validatedQuote = quote ?? 0;
+        const validatedLastMutated = lastMutated ?? "base"; // Default to "base" or your desired default
+        setSwapValues((prev) => {
+            return {
+                ...prev,
+                base: validatedLastMutated === "quote"
+                    ? validatedQuote * currentSwapPair.lastPrice
+                    : validatedBase,
+                quote: validatedLastMutated === "base"
+                    ? validatedBase / currentSwapPair.lastPrice
+                    : validatedQuote,
+                volume: 0,
+                lastMutated: validatedLastMutated,
+            };
+        });
+    }, [setSwapValues, currentSwapPair]);
+    useEffect(() => {
+        setRefreshStatus("idle");
+        setSwapSide("buy");
+        setCurrentMarketProvider(defaultService);
+    }, [defaultService]);
+    useEffect(() => {
+        if (currentMarketProvider)
+            refreshMarketPairs();
+    }, [currentMarketProvider]);
+    useEffect(() => {
+        if (!swapVolume) {
+            return;
+        }
+        if (!currentSwapPair) {
+            return;
+        }
+        if (!currentMarketProvider) {
+            return;
+        }
+        if (!swapSide) {
+            return;
+        }
+        setSwapTransaction(currentMarketProvider.getTransaction(currentSwapPair, swapVolume, 0, swapSide, session ? session : undefined));
+    }, [currentSwapPair, swapVolume, swapSide, currentMarketProvider, session]);
+    React.useEffect(() => {
+        if (!currentMarketPairs || currentMarketPairs.length == 0)
+            return;
+        setCurrentSwapPair(currentMarketPairs[0]);
+    }, [currentMarketPairs]);
+    React.useEffect(() => {
+        if (config && config.sides && config.sides.length == 0) {
+            throw new Error("XPRNProvider config sides could not be empty");
+        }
+        if (!config || !config.sides) {
+            setSwapSide("buy");
+        }
+        if (config && config.sides) {
+            setSwapSide(config.sides[0]);
+        }
+        updateSwapValues(0, 0, "base");
+    }, [config, updateSwapValues]);
+    React.useEffect(() => {
+        if (!swapSide)
+            setSwapVolume(0);
+        if (!currentSwapPair)
+            setSwapVolume(0);
+    }, [swapValues, swapSide, currentSwapPair, setSwapVolume]);
+    const providerValue = useMemo(() => {
+        return {
+            marketProviders: defaultServices,
+            currentMarketProvider,
+            setCurrentMarketProvider,
+            refreshMarketPairs,
+            currentMarketPairs: currentMarketPairs || [],
+            refreshStatus,
+            setCurrentSwapPair,
+            currentSwapPair,
+            swapTransaction,
+            swapSide,
+            setSwapSide,
+            swapVolume,
+            setSwapVolume,
+            config,
+            swapValues,
+            updateSwapValues,
+        };
+    }, [
+        defaultServices,
+        currentMarketProvider,
+        setCurrentMarketProvider,
+        refreshMarketPairs,
+        currentMarketPairs,
+        refreshStatus,
+        setCurrentSwapPair,
+        currentSwapPair,
+        swapTransaction,
+        swapSide,
+        setSwapSide,
+        swapVolume,
+        setSwapVolume,
+        config,
+        swapValues,
+        updateSwapValues,
+    ]);
+    return (_jsx(XPRNSwapContext.Provider, { value: providerValue, children: children }));
+};
+export function useXPRNSwap() {
+    return useContext(XPRNSwapContext);
+}

package/build/components/swap/xprn-swap-side-button.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type XPRNSwapSideButtonProps = React.HTMLAttributes<HTMLDivElement> & {
+    horizontal?: boolean;
+};
+export declare const XPRNSwapSideButton: React.FunctionComponent<XPRNSwapSideButtonProps>;
+export {};

package/build/components/swap/xprn-swap-side-button.js

@@ -0,0 +1,22 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import classNames from "classnames";
+import { useXPRNSwap } from "./xprn-swap-provider";
+import React from "react";
+export const XPRNSwapSideButton = ({ children, className, horizontal }) => {
+    const { config, swapSide, setSwapSide } = useXPRNSwap();
+    const rootClasses = classNames({
+        "transition-transform ": true,
+        "hover:rotate-180": true,
+        [`${className}`]: className,
+    });
+    const onSideSwitch = React.useCallback(() => {
+        swapSide == "sell" ? setSwapSide("buy") : setSwapSide("sell");
+    }, [swapSide, setSwapSide]);
+    const defaultIcon = React.useMemo(() => {
+        if (horizontal)
+            return (_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", strokeLinecap: "round", strokeLinejoin: "round", className: "lucide lucide-arrow-left-right", children: [_jsx("path", { d: "M8 3 4 7l4 4" }), _jsx("path", { d: "M4 7h16" }), _jsx("path", { d: "m16 21 4-4-4-4" }), _jsx("path", { d: "M20 17H4" })] }));
+        return (_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "lucide lucide-arrow-down-up ", children: [_jsx("path", { d: "m3 16 4 4 4-4" }), _jsx("path", { d: "M7 20V4" }), _jsx("path", { d: "m21 8-4-4-4 4" }), _jsx("path", { d: "M17 4v16" })] }));
+    }, [horizontal]);
+    return (_jsx("button", { className: rootClasses, onClick: () => onSideSwitch(), children: _jsx(_Fragment, { children: config && config.sides && config.sides.length == 1 ? null : (_jsx(_Fragment, { children: children ? (children) : (_jsx(_Fragment, { children: defaultIcon })) })) }) }));
+};

package/build/components/swap/xprn-swap.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type XPRNMarketProviderQuoteFilter, type XPRNSwapSide } from ".";
+type XPRNSwapProps = React.HTMLAttributes<HTMLDivElement> & {
+    filters?: XPRNMarketProviderQuoteFilter;
+    sides?: XPRNSwapSide[];
+    markets?: string[];
+};
+export declare const XPRNSwap: React.FunctionComponent<XPRNSwapProps>;
+export {};

package/build/components/swap/xprn-swap.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import classNames from "classnames";
+import { XPRNSwapProvider } from "./xprn-swap-provider";
+import { XPRNSwapLayout } from ".";
+export const XPRNSwap = ({ children, className, filters, sides, markets }) => {
+    const rootClasses = classNames({
+        "grid grid-col-1 gap-4 rounded-md border border-white p-4": true,
+        [`${className}`]: className,
+    });
+    return (_jsx(XPRNSwapProvider, { config: { filters, sides, marketFilters: markets }, children: _jsx(XPRNSwapLayout, {}) }));
+};

package/build/components/ui/dropdown.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/build/components/ui/dropdown.js

@@ -0,0 +1,36 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { CheckIcon, ChevronRightIcon, DotFilledIcon, } from "@radix-ui/react-icons";
+import { cn } from "../../lib/utils";
+const DropdownMenu = DropdownMenuPrimitive.Root;
+const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
+const DropdownMenuGroup = DropdownMenuPrimitive.Group;
+const DropdownMenuPortal = DropdownMenuPrimitive.Portal;
+const DropdownMenuSub = DropdownMenuPrimitive.Sub;
+const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
+const DropdownMenuSubTrigger = React.forwardRef(({ className, inset, children, ...props }, ref) => (_jsxs(DropdownMenuPrimitive.SubTrigger, { ref: ref, className: cn("flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent", inset && "pl-8", className), ...props, children: [children, _jsx(ChevronRightIcon, { className: "ml-auto h-4 w-4" })] })));
+DropdownMenuSubTrigger.displayName =
+    DropdownMenuPrimitive.SubTrigger.displayName;
+const DropdownMenuSubContent = React.forwardRef(({ className, ...props }, ref) => (_jsx(DropdownMenuPrimitive.SubContent, { ref: ref, className: cn("z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className), ...props })));
+DropdownMenuSubContent.displayName =
+    DropdownMenuPrimitive.SubContent.displayName;
+const DropdownMenuContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Portal, { children: _jsx(DropdownMenuPrimitive.Content, { ref: ref, sideOffset: sideOffset, className: cn("z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md", "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className), ...props }) })));
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+const DropdownMenuItem = React.forwardRef(({ className, inset, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Item, { ref: ref, className: cn("relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", inset && "pl-8", className), ...props })));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+const DropdownMenuCheckboxItem = React.forwardRef(({ className, children, checked, ...props }, ref) => (_jsxs(DropdownMenuPrimitive.CheckboxItem, { ref: ref, className: cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className), checked: checked, ...props, children: [_jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: _jsx(DropdownMenuPrimitive.ItemIndicator, { children: _jsx(CheckIcon, { className: "h-4 w-4" }) }) }), children] })));
+DropdownMenuCheckboxItem.displayName =
+    DropdownMenuPrimitive.CheckboxItem.displayName;
+const DropdownMenuRadioItem = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(DropdownMenuPrimitive.RadioItem, { ref: ref, className: cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className), ...props, children: [_jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: _jsx(DropdownMenuPrimitive.ItemIndicator, { children: _jsx(DotFilledIcon, { className: "h-4 w-4 fill-current" }) }) }), children] })));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
+const DropdownMenuLabel = React.forwardRef(({ className, inset, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Label, { ref: ref, className: cn("px-2 py-1.5 text-sm font-semibold", inset && "pl-8", className), ...props })));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
+const DropdownMenuSeparator = React.forwardRef(({ className, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Separator, { ref: ref, className: cn("-mx-1 my-1 h-px bg-muted", className), ...props })));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+const DropdownMenuShortcut = ({ className, ...props }) => {
+    return (_jsx("span", { className: cn("ml-auto text-xs tracking-widest opacity-60", className), ...props }));
+};
+DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/build/components/ui/input.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface BaseInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const Input: React.ForwardRefExoticComponent<BaseInputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/build/components/ui/input.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "./../../lib/utils";
+const Input = React.forwardRef(({ className, type, ...props }, ref) => {
+    return (_jsx("div", { children: _jsx("input", { type: type, className: cn("border border-input bg-transparent h-9 w-full rounded-md px-3 py-1 text-sm  transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground focus-visible:outline-none disabled:cursor-not-allowed disabled:opacity-50", className), ref: ref, ...props }) }));
+});
+Input.displayName = "Input";
+export { Input };

package/build/components/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/build/components/ui/select.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { CaretSortIcon, CheckIcon, ChevronDownIcon, ChevronUpIcon, } from "@radix-ui/react-icons";
+import * as SelectPrimitive from "@radix-ui/react-select";
+import { cn } from "./../../lib/utils";
+const Select = SelectPrimitive.Root;
+const SelectGroup = SelectPrimitive.Group;
+const SelectValue = SelectPrimitive.Value;
+const SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(SelectPrimitive.Trigger, { ref: ref, className: cn("flex h-9 w-full items-center justify-between whitespace-nowrap rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-ring disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1", className), ...props, children: [children, _jsx(SelectPrimitive.Icon, { asChild: true, children: _jsx(CaretSortIcon, { className: "h-4 w-4 opacity-50" }) })] })));
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+const SelectScrollUpButton = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.ScrollUpButton, { ref: ref, className: cn("flex cursor-default items-center justify-center py-1", className), ...props, children: _jsx(ChevronUpIcon, {}) })));
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+const SelectScrollDownButton = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.ScrollDownButton, { ref: ref, className: cn("flex cursor-default items-center justify-center py-1", className), ...props, children: _jsx(ChevronDownIcon, {}) })));
+SelectScrollDownButton.displayName =
+    SelectPrimitive.ScrollDownButton.displayName;
+const SelectContent = React.forwardRef(({ className, children, position = "popper", ...props }, ref) => (_jsx(SelectPrimitive.Portal, { children: _jsxs(SelectPrimitive.Content, { ref: ref, className: cn("relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", position === "popper" &&
+            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1", className), position: position, ...props, children: [_jsx(SelectScrollUpButton, {}), _jsx(SelectPrimitive.Viewport, { className: cn("p-1", position === "popper" &&
+                    "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"), children: children }), _jsx(SelectScrollDownButton, {})] }) })));
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+const SelectLabel = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.Label, { ref: ref, className: cn("px-2 py-1.5 text-sm font-semibold", className), ...props })));
+SelectLabel.displayName = SelectPrimitive.Label.displayName;
+const SelectItem = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(SelectPrimitive.Item, { ref: ref, className: cn("relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-2 pr-8 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className), ...props, children: [_jsx("span", { className: "absolute right-2 flex h-3.5 w-3.5 items-center justify-center", children: _jsx(SelectPrimitive.ItemIndicator, { children: _jsx(CheckIcon, { className: "h-4 w-4" }) }) }), _jsx(SelectPrimitive.ItemText, { children: children })] })));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+const SelectSeparator = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.Separator, { ref: ref, className: cn("-mx-1 my-1 h-px bg-muted", className), ...props })));
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/build/components/xprn-container.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { ReactNode } from "react";
+type XRPNContainerProps = React.HTMLAttributes<HTMLDivElement> & {
+    noSessionState?: ReactNode | ReactNode[];
+};
+export declare const XRPNContainer: React.FunctionComponent<XRPNContainerProps>;
+export declare const XPRNUnlogged: React.FunctionComponent<XRPNContainerProps>;
+export declare const XPRNLogged: React.FunctionComponent<XRPNContainerProps>;
+export {};

package/build/components/xprn-container.js

@@ -0,0 +1,15 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useXPRN } from "../providers/XPRNProvider";
+export const XRPNContainer = ({ children, className, noSessionState, }) => {
+    const { session } = useXPRN();
+    return _jsx(_Fragment, { children: session ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, { children: noSessionState }) });
+};
+export const XPRNUnlogged = ({ children, className, noSessionState, }) => {
+    const { session } = useXPRN();
+    return _jsx(_Fragment, { children: !session ? children : null });
+};
+export const XPRNLogged = ({ children, className, noSessionState, }) => {
+    const { session } = useXPRN();
+    return _jsx(_Fragment, { children: session ? children : null });
+};

package/build/components/xprn-session.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const XPRNConnectButtonVariants: (props?: ({
+    variant?: null | undefined;
+    size?: null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface XPRNConnectButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof XPRNConnectButtonVariants> {
+    asChild?: boolean;
+}
+declare const XPRNConnectButton: React.ForwardRefExoticComponent<XPRNConnectButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { XPRNConnectButton, XPRNConnectButtonVariants };

package/build/components/xprn-session.js

@@ -0,0 +1,21 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useXPRN } from "../providers/XPRNProvider";
+import * as React from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { cn } from "../lib/utils";
+const XPRNConnectButtonVariants = cva("inline-flex items-center justify-center whitespace-nowrap ", {
+    variants: {
+        variant: {},
+        size: {},
+    },
+    defaultVariants: {},
+});
+const XPRNConnectButton = React.forwardRef(({ className, variant, size, asChild = false, onClick, children, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    const { session, connect, disconnect } = useXPRN();
+    return (_jsxs(_Fragment, { children: [!session && (_jsx(Comp, { onClick: () => connect(), className: cn(XPRNConnectButtonVariants({ variant, size, className })), ref: ref, children: children, ...props })), session && (_jsx(Comp, { onClick: () => disconnect(), className: cn(XPRNConnectButtonVariants({ variant, size, className })), ref: ref, children: `Log out (${session.auth.actor.toString()})`, ...props }))] }));
+});
+XPRNConnectButton.displayName = "XPRNConnectButton";
+export { XPRNConnectButton, XPRNConnectButtonVariants };

package/build/components/xprn-transaction.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import type { TransactResult } from "@proton/web-sdk";
+declare const XPRNTransactionVariants: (props?: ({
+    variant?: null | undefined;
+    size?: null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface XPRNTransactionButtonBaseProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof XPRNTransactionVariants> {
+    asChild?: boolean;
+}
+export type XPRNTransactionButtonProps = XPRNTransactionButtonBaseProps & {
+    onTransactionStart?: () => void;
+    onTransactionSuccess?: (res: TransactResult) => void;
+    onTransactionFail?: (e: any) => void;
+    actions: any[];
+};
+declare const XPRNTransaction: React.ForwardRefExoticComponent<XPRNTransactionButtonBaseProps & {
+    onTransactionStart?: () => void;
+    onTransactionSuccess?: (res: TransactResult) => void;
+    onTransactionFail?: (e: any) => void;
+    actions: any[];
+} & React.RefAttributes<HTMLButtonElement>>;
+export { XPRNTransaction, XPRNTransactionVariants };

package/build/components/xprn-transaction.js

@@ -0,0 +1,58 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useXPRN } from "../providers/XPRNProvider";
+import * as React from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { cn } from "../lib/utils";
+const XPRNTransactionVariants = cva("inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50", {
+    variants: {
+        variant: {},
+        size: {},
+    },
+    defaultVariants: {},
+});
+const XPRNTransaction = React.forwardRef(({ className, variant, size, asChild = false, onClick, children, actions, onTransactionStart, onTransactionSuccess, onTransactionFail, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    const { session, connect, addTransactionError, txErrorsStack } = useXPRN();
+    const [txStatus, setTxStatus] = React.useState('idle');
+    const TxStatusNode = React.useMemo(() => {
+        if (txStatus == 'idle')
+            return _jsx(_Fragment, { children: children });
+        if (txStatus == 'pending')
+            return _jsx(_Fragment, { children: _jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", className: "animate-spin", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("path", { d: "M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8" }), _jsx("path", { d: "M21 3v5h-5" }), _jsx("path", { d: "M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16" }), _jsx("path", { d: "M8 16H3v5" })] }) });
+        if (txStatus == 'success')
+            return _jsxs("div", { className: "flex gap-2 justify-center items-center", children: [_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "lucide lucide-circle-check-big", children: [_jsx("path", { d: "M21.801 10A10 10 0 1 1 17 3.335" }), _jsx("path", { d: "m9 11 3 3L22 4" })] }), "Success"] });
+        if (txStatus == 'fail')
+            return _jsxs("div", { className: "flex gap-2 justify-center items-center", children: [_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("circle", { cx: "12", cy: "12", r: "10" }), _jsx("path", { d: "m15 9-6 6" }), _jsx("path", { d: "m9 9 6 6" })] }), "Fail, lease Rety"] });
+    }, [session, txStatus]);
+    const pushTransaction = React.useCallback(() => {
+        if (session) {
+            if (onTransactionStart)
+                onTransactionStart();
+            setTxStatus('pending');
+            try {
+                session.transact({ actions }, { broadcast: true }).then(res => {
+                    if (onTransactionSuccess)
+                        onTransactionSuccess(res);
+                    setTxStatus('success');
+                }).catch((e) => {
+                    setTxStatus('fail');
+                    addTransactionError(e);
+                });
+            }
+            catch (e) {
+                setTxStatus('fail');
+                addTransactionError(e.toString());
+                if (onTransactionFail)
+                    onTransactionFail(e);
+                setTimeout(() => {
+                    setTxStatus('idle');
+                }, 3000);
+            }
+        }
+    }, [session, actions, setTxStatus]);
+    return (_jsxs(_Fragment, { children: [!session && (_jsx(Comp, { onClick: () => connect(false, false, () => pushTransaction()), className: cn(XPRNTransactionVariants({ variant, size, className })), ref: ref, children: "Connecte Me!", ...props })), session && (_jsx(Comp, { onClick: () => pushTransaction(), className: cn(XPRNTransactionVariants({ variant, size, className })), ref: ref, children: TxStatusNode, ...props }))] }));
+});
+XPRNTransaction.displayName = "XPRNTransaction";
+export { XPRNTransaction, XPRNTransactionVariants };