@cryptlex/web-components 5.1.1 → 5.3.0

package/dist/components/inputs/select-options.js

@@ -0,0 +1,286 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const LICENSE_TYPE_OPTIONS = [
+    {
+        label: _jsx(_Fragment, { children: "Node-locked" }),
+        id: "node-locked",
+    },
+    {
+        label: _jsx(_Fragment, { children: "Hosted floating" }),
+        id: "hosted-floating",
+    },
+    {
+        label: _jsx(_Fragment, { children: "LexFloatServer" }),
+        id: "on-premise-floating",
+    },
+];
+/**
+ * Creates Unicode flag from a two-letter ISO country code.
+ * https://stackoverflow.com/questions/24050671/how-to-put-japan-flag-character-in-a-string
+ * @param  {string} country — A two-letter ISO country code (case-insensitive).
+ * @return {string}
+ */
+function getCountryFlag(country) {
+    function getRegionalIndicatorSymbol(letter) {
+        return String.fromCodePoint(0x1f1e6 - 65 + letter.toUpperCase().charCodeAt(0));
+    }
+    return (getRegionalIndicatorSymbol(country[0]) +
+        getRegionalIndicatorSymbol(country[1]));
+}
+const ALL_COUNTRIES = {
+    AF: "Afghanistan",
+    AX: "Åland Islands",
+    AL: "Albania",
+    DZ: "Algeria",
+    AS: "American Samoa",
+    AD: "Andorra",
+    AO: "Angola",
+    AI: "Anguilla",
+    AQ: "Antarctica",
+    AG: "Antigua and Barbuda",
+    AR: "Argentina",
+    AM: "Armenia",
+    AW: "Aruba",
+    AU: "Australia",
+    AT: "Austria",
+    AZ: "Azerbaijan",
+    BS: "Bahamas",
+    BH: "Bahrain",
+    BD: "Bangladesh",
+    BB: "Barbados",
+    BY: "Belarus",
+    BE: "Belgium",
+    BZ: "Belize",
+    BJ: "Benin",
+    BM: "Bermuda",
+    BT: "Bhutan",
+    BO: "Bolivia (Plurinational State of)",
+    BQ: "Bonaire, Sint Eustatius and Saba",
+    BA: "Bosnia and Herzegovina",
+    BW: "Botswana",
+    BV: "Bouvet Island",
+    BR: "Brazil",
+    IO: "British Indian Ocean Territory",
+    BN: "Brunei Darussalam",
+    BG: "Bulgaria",
+    BF: "Burkina Faso",
+    BI: "Burundi",
+    CV: "Caboe Verde",
+    KH: "Cambodia",
+    CM: "Cameroon",
+    CA: "Canada",
+    KY: "Cayman Islands",
+    CF: "Central African Republic",
+    TD: "Chad",
+    CL: "Chile",
+    CN: "China",
+    CX: "Christmas Island",
+    CC: "Cocos (Keeling) Islands",
+    CO: "Colombia",
+    KM: "Comoros",
+    CG: "Congo",
+    CD: "Congo, Democratic Republic of the",
+    CK: "Cook Islands",
+    CR: "Costa Rica",
+    CI: "Côte d'voire",
+    HR: "Croatia",
+    CU: "Cuba",
+    CW: "Curaçao",
+    CY: "Cyprus",
+    CZ: "Czechia",
+    DK: "Denmark",
+    DJ: "Djibouti",
+    DM: "Dominica",
+    DO: "Dominican Republic",
+    EC: "Ecuador",
+    EG: "Egypt",
+    SV: "El Salvador",
+    GQ: "Equatorial Guinea",
+    ER: "Eritrea",
+    EE: "Estonia",
+    SZ: "Eswatini",
+    ET: "Ethiopia",
+    FK: "Falkland Islands (Malvinas)",
+    FO: "Faroe Islands",
+    FJ: "Fiji",
+    FI: "Finland",
+    FR: "France",
+    GF: "French Guiana",
+    PF: "French Polynesia",
+    TF: "French Southern Territories",
+    GA: "Gabon",
+    GM: "Gambia",
+    GE: "Georgia",
+    DE: "Germany",
+    GH: "Ghana",
+    GI: "Gibraltar",
+    GR: "Greece",
+    GL: "Greenland",
+    GD: "Grenada",
+    GP: "Guadeloupe",
+    GU: "Guam",
+    GT: "Guatemala",
+    GG: "Guernsey",
+    GN: "Guinea",
+    GW: "Guinea-Bissau",
+    GY: "Guyana",
+    HT: "Haiti",
+    HM: "Heard Island and Mcdonald Islands",
+    VA: "Holy See",
+    HN: "Honduras",
+    HK: "Hong Kong",
+    HU: "Hungary",
+    IS: "Iceland",
+    IN: "India",
+    ID: "Indonesia",
+    IR: "Iran (Islamic Republic of)",
+    IQ: "Iraq",
+    IE: "Ireland",
+    IM: "Isle of Man",
+    IL: "Israel",
+    IT: "Italy",
+    JM: "Jamaica",
+    JP: "Japan",
+    JE: "Jersey",
+    JO: "Jordan",
+    KZ: "Kazakhstan",
+    KE: "Kenya",
+    KI: "Kiribati",
+    KP: "Korea (Democratic People's Republic of)",
+    KR: "Korea (Republic of)",
+    KW: "Kuwait",
+    KG: "Kyrgyzstan",
+    LA: "Lao People's Democratic Republic",
+    LV: "Latvia",
+    LB: "Lebanon",
+    LS: "Lesotho",
+    LR: "Liberia",
+    LY: "Libya",
+    LI: "Liechtenstein",
+    LT: "Lithuania",
+    LU: "Luxembourg",
+    MO: "Macao",
+    MG: "Madagascar",
+    MW: "Malawi",
+    MY: "Malaysia",
+    MV: "Maldives",
+    ML: "Mali",
+    MT: "Malta",
+    MH: "Marshall Islands",
+    MQ: "Martinique",
+    MR: "Mauritania",
+    MU: "Mauritius",
+    YT: "Mayotte",
+    MX: "Mexico",
+    FM: "Micronesia (Federated States of)",
+    MD: "Moldova, Republic of",
+    MC: "Monaco",
+    MN: "Mongolia",
+    ME: "Montenegro",
+    MS: "Montserrat",
+    MA: "Morocco",
+    MZ: "Mozambique",
+    MM: "Myanmar",
+    NA: "Namibia",
+    NR: "Nauru",
+    NP: "Nepal",
+    NL: "Netherlands, Kingdom of the",
+    NC: "New Caledonia",
+    NZ: "New Zealand",
+    NI: "Nicaragua",
+    NE: "Niger",
+    NG: "Nigeria",
+    NU: "Niue",
+    NF: "Norfolk Island",
+    MK: "North Macedonia",
+    MP: "Northern Mariana Islands",
+    NO: "Norway",
+    OM: "Oman",
+    PK: "Pakistan",
+    PW: "Palau",
+    PS: "Palestine, State of",
+    PA: "Panama",
+    PG: "Papua New Guinea",
+    PY: "Paraguay",
+    PE: "Peru",
+    PH: "Philippines",
+    PN: "Pitcairn",
+    PL: "Poland",
+    PT: "Portugal",
+    PR: "Puerto Rico",
+    QA: "Qatar",
+    RE: "Réunion",
+    RO: "Romania",
+    RU: "Russian Federation",
+    RW: "Rwanda",
+    BL: "Saint Barthélemy",
+    SH: "Saint Helena, Ascension Island, Tristan da Cunha",
+    KN: "Saint Kitts and Nevis",
+    LC: "Saint Lucia",
+    MF: "Saint Martin (French part)",
+    PM: "Saint Pierre and Miquelon",
+    VC: "Saint Vincent and the Grenadines",
+    WS: "Samoa",
+    SM: "San Marino",
+    ST: "Sao Tome and Principe",
+    SA: "Saudi Arabia",
+    SN: "Senegal",
+    RS: "Serbia",
+    SC: "Seychelles",
+    SL: "Sierra Leone",
+    SG: "Singapore",
+    SX: "Sint Maarten (Dutch part)",
+    SK: "Slovakia",
+    SI: "Slovenia",
+    SB: "Solomon Islands",
+    SO: "Somalia",
+    ZA: "South Africa",
+    GS: "South Georgia and the South Sandwich Islands",
+    SS: "South Sudan",
+    ES: "Spain",
+    LK: "Sri Lanka",
+    SD: "Sudan",
+    SR: "Suriname",
+    SJ: "Svalbard and Jan Mayen",
+    SE: "Sweden",
+    CH: "Switzerland",
+    SY: "Syrian Arab Republic",
+    TW: "Taiwan, Province of China",
+    TJ: "Tajikistan",
+    TZ: "Tanzania, United Republic of",
+    TH: "Thailand",
+    TL: "Timor-Leste",
+    TG: "Togo",
+    TK: "Tokelau",
+    TO: "Tonga",
+    TT: "Trinidad and Tobago",
+    TN: "Tunisia",
+    TR: "Türkiye",
+    TM: "Turkmenistan",
+    TC: "Turks and Caicos Islands",
+    TV: "Tuvalu",
+    UG: "Uganda",
+    UA: "Ukraine",
+    AE: "United Arab Emirates",
+    GB: "United Kingdom of Great Britain and Northern Ireland",
+    UM: "United States Minor Outlying Islands",
+    US: "United States of America",
+    UY: "Uruguay",
+    UZ: "Uzbekistan",
+    VU: "Vanuatu",
+    VE: "Venezuela (Bolivarian Republic of)",
+    VN: "Viet Nam",
+    VG: "Virgin Islands (British)",
+    VI: "Virgin Islands (U.S)",
+    WF: "Wallis and Futuna",
+    EH: "Western Sahara",
+    YE: "Yemen",
+    ZM: "Zambia",
+    ZW: "Zimbabwe",
+};
+/** Options for MultiSelect component */
+export const COUNTRY_OPTIONS = Object.entries(ALL_COUNTRIES).map((v) => {
+    return {
+        label: (_jsxs(_Fragment, { children: [getCountryFlag(v[0]), " ", v[1]] })),
+        id: v[0],
+    };
+});

package/dist/components/inputs/select.d.ts

@@ -0,0 +1,17 @@
+import { PopoverProps as AriaPopoverProps, SelectProps as AriaSelectProps, SelectValueProps as AriaSelectValueProps } from "react-aria-components";
+import { type FormFieldProps } from "lib/components/inputs/field";
+import type { SelectOption } from "lib/components/inputs/select-options";
+import { ListBoxHeader, ListBoxItem } from "../ui/list-box";
+export declare const SelectItem: typeof ListBoxItem;
+export declare const SelectHeader: typeof ListBoxHeader;
+export declare const SelectCollection: typeof import("react-aria-components").Collection;
+export declare const SelectValue: <T extends object>({ className, ...props }: AriaSelectValueProps<T>) => import("react/jsx-runtime").JSX.Element;
+export declare function SelectPopover({ className, ...props }: AriaPopoverProps): import("react/jsx-runtime").JSX.Element;
+export interface SingleSelectProps<T extends SelectOption> extends Omit<AriaSelectProps<T>, "children">, FormFieldProps {
+    items: Iterable<T>;
+    children: React.ReactNode | ((item: T) => React.ReactNode);
+}
+export declare function SingleSelect<T extends SelectOption>({ label, description, errorMessage, children, className, items, ...props }: SingleSelectProps<T>): import("react/jsx-runtime").JSX.Element;
+type TfSingleSelectProps<T extends SelectOption> = Omit<SingleSelectProps<T>, "value" | "setValue" | 'children'>;
+export declare function TfSingleSelect<T extends SelectOption>({ ...props }: TfSingleSelectProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/inputs/select.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ListBox as AriaListBox, Select as AriaSelect, SelectValue as AriaSelectValue, composeRenderProps } from "react-aria-components";
+import { FormField } from "lib/components/inputs/field";
+import { Button } from "lib/components/ui/button";
+import { useFieldContext } from "lib/utils/form-context";
+import { getFieldErrorMessage } from "lib/utils/form-hook";
+import { cn } from "lib/utils/primitives";
+import { ChevronDown } from "lucide-react";
+import { ListBoxCollection, ListBoxHeader, ListBoxItem, } from "../ui/list-box";
+import { Popover } from "../ui/popover";
+const ASelect = AriaSelect;
+export const SelectItem = ListBoxItem;
+export const SelectHeader = ListBoxHeader;
+export const SelectCollection = ListBoxCollection;
+export const SelectValue = ({ className, ...props }) => (_jsx(AriaSelectValue, { className: composeRenderProps(className, (className) => cn("line-clamp-1 data-[placeholder]:text-muted-foreground", 
+    /* Description */
+    "[&>[slot=description]]:hidden", className)), ...props }));
+function SelectTrigger({ className, children, ...props }) {
+    return (_jsx(Button, { ...props, children: composeRenderProps(children, (children) => (_jsxs(_Fragment, { children: [children, _jsx(ChevronDown, { "aria-hidden": "true", className: "size-icon opacity-50" })] }))) }));
+}
+export function SelectPopover({ className, ...props }) {
+    return (_jsx(Popover, { className: composeRenderProps(className, (className) => cn("w-auto min-w-[--trigger-width]", className)), ...props }));
+}
+function SelectListBox({ className, ...props }) {
+    return (_jsx(AriaListBox, { className: composeRenderProps(className, (className) => cn("overflow-auto p-1 outline-none [clip-path:inset(0_0_0_0_round_calc(var(--radius)-2px))]", className)), ...props }));
+}
+export function SingleSelect({ label, description, errorMessage, children, className, items, ...props }) {
+    return (_jsx(ASelect, { className: composeRenderProps(className, (className) => cn("group form-field", className)), ...props, children: _jsxs(FormField, { label: label, description: description, errorMessage: errorMessage, children: [_jsx(SelectTrigger, { children: _jsx(SelectValue, {}) }), _jsx(SelectPopover, { children: _jsx(SelectListBox, { items: items, children: children }) })] }) }));
+}
+export function TfSingleSelect({ ...props }) {
+    const field = useFieldContext();
+    return (_jsx(SingleSelect, { selectedKey: field.state.value, onSelectionChange: (e) => field.handleChange(e.toString()), onBlur: field.handleBlur, errorMessage: getFieldErrorMessage(field), ...props, children: (item) => _jsx(SelectItem, { id: item.id, children: item.label }, item.id) }));
+}

package/dist/components/inputs/textfield.d.ts

@@ -0,0 +1,7 @@
+import { TextFieldProps as AriaTextFieldProps } from "react-aria-components";
+import { type FormFieldProps } from "./field";
+export interface TextFieldProps extends AriaTextFieldProps, FormFieldProps {
+    textArea?: boolean;
+}
+export declare function TextField({ label, description, errorMessage, textArea, className, ...props }: TextFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function TfTextField({ isDisabled, ...props }: React.ComponentProps<typeof TextField>): import("react/jsx-runtime").JSX.Element;

package/dist/components/inputs/textfield.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Input as AriaInput, TextArea as AriaTextArea, TextField as AriaTextField, composeRenderProps } from "react-aria-components";
+import { useFieldContext } from "lib/utils/form-context";
+import { getFieldErrorMessage } from "lib/utils/form-hook";
+import { cn } from "lib/utils/primitives";
+import { FormField } from "./field";
+const ATextField = AriaTextField;
+function Input({ className, ...props }) {
+    return (_jsx(AriaInput, { className: composeRenderProps(className, (className) => cn("flex input-dim w-full border border-input bg-card ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground", 
+        /* Disabled */
+        "disabled-muted", 
+        /* Focused */
+        "focus-ring", className)), ...props }));
+}
+function TextArea({ className, ...props }) {
+    return (_jsx(AriaTextArea, { className: composeRenderProps(className, (className) => cn("flex min-h-32 w-full border border-input bg-card px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground", 
+        /* Focused */
+        "focus-ring", 
+        /* Disabled */
+        "disabled-muted", className)), ...props }));
+}
+export function TextField({ label, description, errorMessage, textArea, className, ...props }) {
+    return (_jsx(ATextField, { className: composeRenderProps(className, (className) => cn("group form-field", className)), ...props, children: _jsx(FormField, { label: label, errorMessage: errorMessage, description: description, children: textArea ? _jsx(TextArea, {}) : _jsx(Input, {}) }) }));
+}
+export function TfTextField({ isDisabled, ...props }) {
+    const field = useFieldContext();
+    return (_jsx(TextField, { isDisabled: isDisabled || field.form.state.isSubmitting, value: field.state.value, id: field.name, name: field.name, onBlur: field.handleBlur, onChange: field.handleChange, errorMessage: getFieldErrorMessage(field), ...props }));
+}

package/dist/components/key-value-card/key-value-card.d.ts

@@ -0,0 +1,17 @@
+type NestedKeyOf<T> = T extends object ? {
+    [K in keyof T]: K extends string | number ? `${K & string}` | `${K & string}.${NestedKeyOf<T[K]>}` : never;
+}[keyof T] : never;
+export type DisplayField<T> = {
+    display: string;
+    accessor: NestedKeyOf<T>;
+    type?: "text" | "badge" | "boolean" | "date" | "yesno" | "copyButton" | "link";
+    transform?: (value: any) => React.ReactNode;
+};
+export interface KeyValueCardProps<T> {
+    data: T;
+    label: string;
+    fields: DisplayField<T>[];
+    className?: string;
+}
+export declare const KeyValueCard: <T extends {}>({ data, label, fields, }: KeyValueCardProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/key-value-card/key-value-card.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatDate } from "lib/components/data-table/table-commons";
+import { Badge } from "lib/components/ui/badge";
+import { Card, CardContent, CardHeader, CardTitle } from "lib/components/ui/card";
+import { Skeleton } from "lib/components/ui/skeleton";
+export const KeyValueCard = ({ data, label, fields, }) => {
+    const renderValue = (field, value) => {
+        if (field.transform) {
+            return field.transform(value);
+        }
+        if (value === undefined || value === null) {
+            return "-";
+        }
+        switch (field.type) {
+            case "date":
+                return _jsx("span", { children: formatDate(value) });
+            case "yesno":
+                return _jsx("span", { children: value ? "Yes" : "No" });
+            case "badge":
+                return (_jsx("div", { className: "flex flex-wrap gap-1", children: Array.isArray(value)
+                        ? value.map((item, index) => (_jsx(Badge, { children: typeof item === "object" ? item?.name || item?.id : item }, index)))
+                        : value }));
+            case "boolean":
+                return _jsx("span", { children: value.toString() });
+            default:
+                return _jsx("span", { children: value });
+        }
+    };
+    return (_jsxs(Card, { children: [_jsx(CardHeader, { children: _jsx(CardTitle, { children: label }) }), _jsx(CardContent, { children: _jsx("div", { className: "flex flex-col gap-2", children: data
+                        ? fields.map((field) => {
+                            // TODO: improve this
+                            const value = field.accessor
+                                ? field.accessor
+                                    .split(".")
+                                    .reduce((obj, key) => obj && key in obj ? obj[key] : undefined, data)
+                                : null;
+                            return (_jsxs("div", { className: "flex w-full flex-col md:flex-row justify-between first:pt-0 last:pb-0", children: [_jsx("p", { className: "text-sm flex w-full justify-start col-span-1", children: field.display }), _jsx("div", { className: "text-sm flex w-full justify-start text-wrap break-all", children: renderValue(field, value) })] }, field.display));
+                        })
+                        : fields.map((_, index) => (_jsx(Skeleton, { className: "h-12 w-full" }, index))) }) })] }));
+};

package/dist/components/ui/alert.d.ts

@@ -0,0 +1,8 @@
+import { type VariantProps } from "class-variance-authority";
+import { type LucideIcon } from "lucide-react";
+export declare const alertVariants: (props?: ({
+    variant?: "destructive" | "success" | "muted" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare function Alert({ children, className, variant, icon: Icon, ...props }: React.ComponentProps<'div'> & VariantProps<typeof alertVariants> & {
+    icon?: LucideIcon;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/alert.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { cn } from "lib/utils/primitives";
+export const alertVariants = cva(`transition-colors border border-dotted p-2 text-foreground text-sm inline-flex items-start gap-2`, {
+    variants: {
+        variant: {
+            destructive: "bg-destructive-foreground/20 text-destructive border-destructive",
+            success: "bg-success-foreground/20 text-success border-success",
+            muted: "bg-muted-foreground/20 text-muted border-muted",
+        },
+    },
+    defaultVariants: {
+        variant: "muted",
+    },
+});
+export function Alert({ children, className, variant, icon: Icon, ...props }) {
+    return (_jsxs("div", { role: "alert", className: cn(alertVariants({ variant }), className), ...props, children: [Icon && _jsx(Icon, { className: "size-icon mt-1" }), _jsx("span", { className: "w-full", children: children })] }));
+}

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,8 @@
+import type * as React from "react";
+interface InitialString {
+    initials: string[2];
+}
+export interface AvatarProps extends Omit<React.ComponentProps<"div">, "children">, InitialString {
+}
+export declare function Avatar({ className, initials, ...props }: AvatarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/avatar.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from "lib/utils/primitives";
+export function Avatar({ className, initials, ...props }) {
+    return (_jsx("div", { className: cn("relative text-xs font-mono font-bold flex items-center leading-none justify-center bg-accent text-accent-foreground select-none size-input shrink-0 overflow-hidden rounded-full", className), ...props, children: initials }));
+}

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,2 @@
+import type * as React from "react";
+export declare function Badge({ className, children, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/badge.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from "lib/utils/primitives";
+export function Badge({ className, children, ...props }) {
+    return (_jsx("span", { className: cn("text-muted leading-none text-sm px-1 inline-flex items-center justify-center select-none bg-card border h-input focus:outline-hidden focus:ring-1 focus:ring-ring", className), ...props, children: _jsx("span", { children: children }) }));
+}

package/dist/components/ui/breadcrumbs.d.ts

@@ -0,0 +1,10 @@
+import { BreadcrumbProps as AriaBreadcrumbProps, BreadcrumbsProps as AriaBreadcrumbsProps, LinkProps as AriaLinkProps } from "react-aria-components";
+export declare function Breadcrumbs<T extends object>({ className, ...props }: AriaBreadcrumbsProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function BreadcrumbItem({ className, ...props }: AriaBreadcrumbProps): import("react/jsx-runtime").JSX.Element;
+export declare function BreadcrumbLink({ className, ...props }: AriaLinkProps): import("react/jsx-runtime").JSX.Element;
+export declare function BreadcrumbSeparator({ children, className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export declare function BreadcrumbEllipsis({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+interface BreadcrumbPageProps extends Omit<AriaLinkProps, "href"> {
+}
+export declare function BreadcrumbPage({ className, ...props }: BreadcrumbPageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/breadcrumbs.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Breadcrumb as AriaBreadcrumb, Breadcrumbs as AriaBreadcrumbs, Link as AriaLink, composeRenderProps, } from "react-aria-components";
+import { cn } from "lib/utils/primitives";
+import { ChevronRight, DotSquare } from "lucide-react";
+export function Breadcrumbs({ className, ...props }) {
+    return (_jsx(AriaBreadcrumbs, { className: cn("flex flex-wrap items-center gap-1.5 break-words text-sm text-muted-foreground sm:gap-2.5", className), ...props }));
+}
+export function BreadcrumbItem({ className, ...props }) {
+    return (_jsx(AriaBreadcrumb, { className: cn("inline-flex items-center gap-1.5 sm:gap-2.5", className), ...props }));
+}
+export function BreadcrumbLink({ className, ...props }) {
+    return (_jsx(AriaLink, { className: composeRenderProps(className, (className) => cn("transition-colors", 
+        /* Hover */
+        "data-[hovered]:text-foreground", 
+        /* Disabled */
+        "data-[disabled]:pointer-events-none data-[disabled]:opacity-50", 
+        /* Current */
+        "data-[current]:pointer-events-auto data-[current]:opacity-100", className)), ...props }));
+}
+export function BreadcrumbSeparator({ children, className, ...props }) {
+    return (_jsx("span", { role: "presentation", "aria-hidden": "true", className: cn("[&>svg]:size-3.5", className), ...props, children: children || _jsx(ChevronRight, {}) }));
+}
+export function BreadcrumbEllipsis({ className, ...props }) {
+    return (_jsxs("span", { role: "presentation", "aria-hidden": "true", className: cn("flex size-9 items-center justify-center", className), ...props, children: [_jsx(DotSquare, { className: "size-4" }), _jsx("span", { className: "sr-only", children: "More" })] }));
+}
+export function BreadcrumbPage({ className, ...props }) {
+    return (_jsx(AriaLink, { className: composeRenderProps(className, (className) => cn("font-normal text-foreground", className)), ...props }));
+}

package/dist/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from "class-variance-authority";
+import { type ButtonProps as AriaButtonProps } from "react-aria-components";
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "ghost" | "primary" | "secondary" | "destructive" | "neutral" | null | undefined;
+    size?: "default" | "none" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ButtonProps = AriaButtonProps & VariantProps<typeof buttonVariants> & {
+    ref?: React.Ref<HTMLButtonElement>;
+    active?: boolean;
+};
+export declare function Button({ className: additionalClasses, variant, size, children, isPending, active, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/button.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { cn } from "lib/utils/primitives";
+import { Button as AriaButton, composeRenderProps, } from "react-aria-components";
+import { Loader } from "./loader";
+export const buttonVariants = cva("btn inline-flex gap-1 text-ellipsis overflow-hidden items-center justify-center font-medium transition-colors", {
+    variants: {
+        variant: {
+            primary: "btn-primary",
+            secondary: "btn-secondary",
+            destructive: "btn-destructive",
+            neutral: "btn-neutral",
+            ghost: "btn-ghost",
+            link: "text-primary underline-offset-4 hover:underline",
+        },
+        size: {
+            default: "input-dim",
+            icon: "size-input",
+            none: ""
+        },
+    },
+    defaultVariants: {
+        variant: "neutral",
+        size: "default",
+    },
+});
+export function Button({ className: additionalClasses, variant, size, children, isPending, active, ...props }) {
+    return (_jsx(AriaButton, { ...props, className: composeRenderProps(additionalClasses, (className) => cn(buttonVariants({
+            variant,
+            size,
+            className,
+        }), additionalClasses)), children: composeRenderProps(children, (children) => (_jsxs(_Fragment, { children: [isPending && _jsx(Loader, {}), !isPending && _jsx(_Fragment, { children: children })] }))) }));
+}

package/dist/components/ui/calendar.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { CalendarCellProps as AriaCalendarCellProps, CalendarGridBodyProps as AriaCalendarGridBodyProps, CalendarGridProps as AriaCalendarGridProps, CalendarHeaderCellProps as AriaCalendarHeaderCellProps, CalendarProps as AriaCalendarProps, DateValue as AriaDateValue, RangeCalendarProps as AriaRangeCalendarProps } from "react-aria-components";
+export declare function CalendarHeading(props: React.HTMLAttributes<HTMLElement>): import("react/jsx-runtime").JSX.Element;
+export declare function CalendarGrid({ className, ...props }: AriaCalendarGridProps): import("react/jsx-runtime").JSX.Element;
+export declare const CalendarGridHeader: (props: import("react-aria-components").CalendarGridHeaderProps & React.RefAttributes<HTMLTableSectionElement>) => React.ReactElement | null;
+export declare function CalendarHeaderCell({ className, ...props }: AriaCalendarHeaderCellProps): import("react/jsx-runtime").JSX.Element;
+export declare function CalendarGridBody({ className, ...props }: AriaCalendarGridBodyProps): import("react/jsx-runtime").JSX.Element;
+export declare function CalendarCell({ className, ...props }: AriaCalendarCellProps): import("react/jsx-runtime").JSX.Element;
+interface CalendarProps<T extends AriaDateValue> extends AriaCalendarProps<T> {
+    errorMessage?: string;
+}
+export declare function Calendar<T extends AriaDateValue>({ errorMessage, className, ...props }: CalendarProps<T>): import("react/jsx-runtime").JSX.Element;
+interface RangeCalendarProps<T extends AriaDateValue> extends AriaRangeCalendarProps<T> {
+    errorMessage?: string;
+}
+export declare function RangeCalendar<T extends AriaDateValue>({ errorMessage, className, ...props }: RangeCalendarProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};