@vinyasa/feedback 1.0.21

package/dist/esm/703.js

@@ -0,0 +1,56 @@
+import "./703.css";
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { createRuntimeFn } from "./953.js";
+import { resolveSpacingStyle } from "./474.js";
+var spinner = createRuntimeFn({
+    defaultClassName: '_8naz5u1',
+    variantClassNames: {
+        size: {
+            sm: '_8naz5u3',
+            md: '_8naz5u4',
+            lg: '_8naz5u5'
+        }
+    },
+    defaultVariants: {
+        size: 'md'
+    },
+    compoundVariants: []
+});
+const Spinner = /*#__PURE__*/ forwardRef(({ size, m, mt, mr, mb, ml, mx, my, p, pt, pr, pb, pl, px, py, className, style, ...rest }, ref)=>{
+    const classes = className ? `${spinner({
+        size
+    })} ${className}` : spinner({
+        size
+    });
+    const computedStyle = {
+        ...resolveSpacingStyle({
+            m,
+            mt,
+            mr,
+            mb,
+            ml,
+            mx,
+            my,
+            p,
+            pt,
+            pr,
+            pb,
+            pl,
+            px,
+            py
+        }),
+        ...style
+    };
+    return /*#__PURE__*/ jsx("span", {
+        ref: ref,
+        role: "status",
+        "aria-label": "Loading",
+        className: classes,
+        style: computedStyle,
+        ...rest
+    });
+});
+Spinner.displayName = 'Spinner';
+const spinner_Spinner = Spinner;
+export { spinner_Spinner as Spinner };

package/dist/esm/872.css

@@ -0,0 +1,15 @@
+._1ie0lek0 {
+  background-color: var(--vinyasa-secondary);
+  border-radius: var(--vinyasa-radius-full);
+  width: 100%;
+  height: .5rem;
+  overflow: hidden;
+}
+
+._1ie0lek1 {
+  background-color: var(--vinyasa-primary);
+  border-radius: var(--vinyasa-radius-full);
+  height: 100%;
+  transition: width var(--vinyasa-motion-duration-normal) var(--vinyasa-motion-easing-standard);
+}
+

package/dist/esm/872.js

@@ -0,0 +1,29 @@
+import "./872.css";
+import { jsx } from "react/jsx-runtime";
+import box from "@vinyasa/layout/box";
+import { forwardRef } from "react";
+var fill = '_1ie0lek1';
+var track = '_1ie0lek0';
+const ProgressBar = /*#__PURE__*/ forwardRef(({ value, max = 100, className, style, ...rest }, ref)=>{
+    const classes = className ? `${track} ${className}` : track;
+    const percent = Math.min(100, Math.max(0, value / max * 100));
+    return /*#__PURE__*/ jsx(box, {
+        ref: ref,
+        role: "progressbar",
+        "aria-valuenow": value,
+        "aria-valuemin": 0,
+        "aria-valuemax": max,
+        className: classes,
+        style: style,
+        ...rest,
+        children: /*#__PURE__*/ jsx("div", {
+            className: fill,
+            style: {
+                width: `${String(percent)}%`
+            }
+        })
+    });
+});
+ProgressBar.displayName = 'ProgressBar';
+const progress_bar_ProgressBar = ProgressBar;
+export { progress_bar_ProgressBar as ProgressBar };

package/dist/esm/880.js

@@ -0,0 +1,47 @@
+import { jsx } from "react/jsx-runtime";
+import _vinyasa_button from "@vinyasa/button";
+import { Component } from "react";
+import { EmptyState as empty_state_EmptyState } from "./288.js";
+class ErrorBoundary extends Component {
+    state = {
+        error: null
+    };
+    static getDerivedStateFromError(error) {
+        return {
+            error
+        };
+    }
+    componentDidCatch(error, errorInfo) {
+        this.props.onError?.(error, errorInfo);
+    }
+    componentDidUpdate(prevProps) {
+        const { error } = this.state;
+        const { resetKeys } = this.props;
+        if (error && resetKeys && prevProps.resetKeys && resetKeys.some((key, index)=>key !== prevProps.resetKeys?.[index])) this.reset();
+    }
+    reset = ()=>{
+        this.props.onReset?.();
+        this.setState({
+            error: null
+        });
+    };
+    render() {
+        const { error } = this.state;
+        if (!error) return this.props.children;
+        const { fallback } = this.props;
+        if ('function' == typeof fallback) return fallback({
+            error,
+            resetErrorBoundary: this.reset
+        });
+        return fallback ?? /*#__PURE__*/ jsx(empty_state_EmptyState, {
+            title: "Something went wrong",
+            description: error.message,
+            action: /*#__PURE__*/ jsx(_vinyasa_button, {
+                onClick: this.reset,
+                children: "Try again"
+            })
+        });
+    }
+}
+const error_boundary_ErrorBoundary = ErrorBoundary;
+export { error_boundary_ErrorBoundary as ErrorBoundary };

package/dist/esm/903.css

@@ -0,0 +1,51 @@
+._1313gq0 {
+  align-items: flex-start;
+  gap: var(--vinyasa-space3);
+  padding: var(--vinyasa-space4);
+  border-radius: var(--vinyasa-radius-md);
+  font-family: var(--vinyasa-font-family-sans);
+  display: flex;
+}
+
+._1313gq1 {
+  background-color: var(--vinyasa-status-info-bg);
+  color: var(--vinyasa-status-info-text);
+}
+
+._1313gq2 {
+  background-color: var(--vinyasa-status-success-bg);
+  color: var(--vinyasa-status-success-text);
+}
+
+._1313gq3 {
+  background-color: var(--vinyasa-status-warning-bg);
+  color: var(--vinyasa-status-warning-text);
+}
+
+._1313gq4 {
+  background-color: var(--vinyasa-status-error-bg);
+  color: var(--vinyasa-status-error-text);
+}
+
+._1313gq5 {
+  flex-shrink: 0;
+  margin-top: .125em;
+}
+
+._1313gq6 {
+  gap: var(--vinyasa-space1);
+  flex-direction: column;
+  display: flex;
+}
+
+._1313gq7 {
+  font-size: var(--vinyasa-font-size-sm);
+  font-weight: var(--vinyasa-font-weight-semibold);
+  margin: 0;
+}
+
+._1313gq8 {
+  font-size: var(--vinyasa-font-size-sm);
+  margin: 0;
+}
+

package/dist/esm/903.js

@@ -0,0 +1,61 @@
+import "./903.css";
+import { jsx, jsxs } from "react/jsx-runtime";
+import box from "@vinyasa/layout/box";
+import { forwardRef } from "react";
+import { createRuntimeFn } from "./953.js";
+import { statusIcons } from "./277.js";
+var Alert_css_alert = createRuntimeFn({
+    defaultClassName: '_1313gq0',
+    variantClassNames: {
+        status: {
+            info: '_1313gq1',
+            success: '_1313gq2',
+            warning: '_1313gq3',
+            error: '_1313gq4'
+        }
+    },
+    defaultVariants: {
+        status: 'info'
+    },
+    compoundVariants: []
+});
+var body = '_1313gq6';
+var Alert_css_description = '_1313gq8';
+var icon = '_1313gq5';
+var Alert_css_title = '_1313gq7';
+const Alert = /*#__PURE__*/ forwardRef(({ status = 'info', title, description, className, ...rest }, ref)=>{
+    const Icon = statusIcons[status];
+    const classes = className ? `${Alert_css_alert({
+        status
+    })} ${className}` : Alert_css_alert({
+        status
+    });
+    return /*#__PURE__*/ jsxs(box, {
+        ref: ref,
+        role: "alert",
+        className: classes,
+        ...rest,
+        children: [
+            /*#__PURE__*/ jsx(Icon, {
+                className: icon,
+                "aria-hidden": "true"
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: body,
+                children: [
+                    /*#__PURE__*/ jsx("p", {
+                        className: Alert_css_title,
+                        children: title
+                    }),
+                    description ? /*#__PURE__*/ jsx("p", {
+                        className: Alert_css_description,
+                        children: description
+                    }) : null
+                ]
+            })
+        ]
+    });
+});
+Alert.displayName = 'Alert';
+const alert_Alert = Alert;
+export { alert_Alert as Alert };

package/dist/esm/953.js

@@ -0,0 +1,87 @@
+function toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+        var i = e.call(t, r || "default");
+        if ("object" != typeof i) return i;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+}
+function toPropertyKey(t) {
+    var i = toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : String(i);
+}
+function _defineProperty(obj, key, value) {
+    key = toPropertyKey(key);
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+        var o = Object.getOwnPropertySymbols(e);
+        r && (o = o.filter(function(r) {
+            return Object.getOwnPropertyDescriptor(e, r).enumerable;
+        })), t.push.apply(t, o);
+    }
+    return t;
+}
+function _objectSpread2(e) {
+    for(var r = 1; r < arguments.length; r++){
+        var t = null != arguments[r] ? arguments[r] : {};
+        r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+            _defineProperty(e, r, t[r]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+            Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+        });
+    }
+    return e;
+}
+function mapValues(input, fn) {
+    var result = {};
+    for(var _key in input)result[_key] = fn(input[_key], _key);
+    return result;
+}
+var shouldApplyCompound = (compoundCheck, selections, defaultVariants)=>{
+    for (var key of Object.keys(compoundCheck)){
+        var _selections$key;
+        if (compoundCheck[key] !== (null != (_selections$key = selections[key]) ? _selections$key : defaultVariants[key])) return false;
+    }
+    return true;
+};
+var createRuntimeFn = (config)=>{
+    var runtimeFn = (options)=>{
+        var className = config.defaultClassName;
+        var selections = _objectSpread2(_objectSpread2({}, config.defaultVariants), options);
+        for(var variantName in selections){
+            var _selections$variantNa;
+            var variantSelection = null != (_selections$variantNa = selections[variantName]) ? _selections$variantNa : config.defaultVariants[variantName];
+            if (null != variantSelection) {
+                var selection = variantSelection;
+                if ('boolean' == typeof selection) selection = true === selection ? 'true' : 'false';
+                var selectionClassName = config.variantClassNames[variantName][selection];
+                if (selectionClassName) className += ' ' + selectionClassName;
+            }
+        }
+        for (var [compoundCheck, compoundClassName] of config.compoundVariants)if (shouldApplyCompound(compoundCheck, selections, config.defaultVariants)) className += ' ' + compoundClassName;
+        return className;
+    };
+    runtimeFn.variants = ()=>Object.keys(config.variantClassNames);
+    runtimeFn.classNames = {
+        get base () {
+            return config.defaultClassName.split(' ')[0];
+        },
+        get variants () {
+            return mapValues(config.variantClassNames, (classNames)=>mapValues(classNames, (className)=>className.split(' ')[0]));
+        }
+    };
+    return runtimeFn;
+};
+export { createRuntimeFn };

package/dist/esm/989.css

@@ -0,0 +1,37 @@
+.a1nlu90 {
+  justify-content: flex-start;
+  align-items: center;
+  gap: var(--vinyasa-space2);
+  width: 100%;
+  padding: var(--vinyasa-space3);
+  font-family: var(--vinyasa-font-family-sans);
+  font-size: var(--vinyasa-font-size-sm);
+  font-weight: var(--vinyasa-font-weight-medium);
+  display: flex;
+}
+
+.a1nlu91 {
+  background-color: var(--vinyasa-status-info-bg);
+  color: var(--vinyasa-status-info-text);
+}
+
+.a1nlu92 {
+  background-color: var(--vinyasa-status-success-bg);
+  color: var(--vinyasa-status-success-text);
+}
+
+.a1nlu93 {
+  background-color: var(--vinyasa-status-warning-bg);
+  color: var(--vinyasa-status-warning-text);
+}
+
+.a1nlu94 {
+  background-color: var(--vinyasa-status-error-bg);
+  color: var(--vinyasa-status-error-text);
+}
+
+.a1nlu95 {
+  flex-shrink: 0;
+  margin-top: -.05em;
+}
+

package/dist/esm/989.js

@@ -0,0 +1,46 @@
+import "./989.css";
+import { jsx, jsxs } from "react/jsx-runtime";
+import box from "@vinyasa/layout/box";
+import { forwardRef } from "react";
+import { createRuntimeFn } from "./953.js";
+import { statusIcons } from "./277.js";
+var banner = createRuntimeFn({
+    defaultClassName: 'a1nlu90',
+    variantClassNames: {
+        status: {
+            info: 'a1nlu91',
+            success: 'a1nlu92',
+            warning: 'a1nlu93',
+            error: 'a1nlu94'
+        }
+    },
+    defaultVariants: {
+        status: 'info'
+    },
+    compoundVariants: []
+});
+var icon = 'a1nlu95';
+const Banner = /*#__PURE__*/ forwardRef(({ status = 'info', className, children, ...rest }, ref)=>{
+    const Icon = statusIcons[status];
+    const classes = className ? `${banner({
+        status
+    })} ${className}` : banner({
+        status
+    });
+    return /*#__PURE__*/ jsxs(box, {
+        ref: ref,
+        role: "alert",
+        className: classes,
+        ...rest,
+        children: [
+            /*#__PURE__*/ jsx(Icon, {
+                className: icon,
+                "aria-hidden": "true"
+            }),
+            children
+        ]
+    });
+});
+Banner.displayName = 'Banner';
+const banner_Banner = Banner;
+export { banner_Banner as Banner };

package/dist/esm/alert.d.ts

@@ -0,0 +1,2 @@
+export * from './components/alert/index';
+export { default } from './components/alert/index';

package/dist/esm/alert.js

@@ -0,0 +1 @@
+export { Alert as default } from "./903.js";

package/dist/esm/banner.d.ts

@@ -0,0 +1,2 @@
+export * from './components/banner/index';
+export { default } from './components/banner/index';

package/dist/esm/banner.js

@@ -0,0 +1 @@
+export { Banner as default } from "./989.js";

package/dist/esm/circular-progress.d.ts

@@ -0,0 +1,2 @@
+export * from './components/circular-progress/index';
+export { default } from './components/circular-progress/index';

package/dist/esm/circular-progress.js

@@ -0,0 +1 @@
+export { CircularProgress as default } from "./266.js";

package/dist/esm/components/alert/Alert.css.d.ts

@@ -0,0 +1,24 @@
+export declare const alert: import("@vanilla-extract/recipes").RuntimeFn<{
+    status: {
+        info: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+        success: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+        warning: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+        error: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+    };
+}>;
+export declare const icon: string;
+export declare const body: string;
+export declare const title: string;
+export declare const description: string;

package/dist/esm/components/alert/Alert.d.ts

@@ -0,0 +1,14 @@
+import { type BoxProps } from '@vinyasa/layout/box';
+import { type ReactNode } from 'react';
+import { type Status } from '../../status';
+export type AlertProps = Omit<BoxProps, 'title'> & {
+    status?: Status;
+    title: ReactNode;
+    description?: ReactNode;
+};
+declare const Alert: import("react").ForwardRefExoticComponent<Omit<BoxProps, "title"> & {
+    status?: Status;
+    title: ReactNode;
+    description?: ReactNode;
+} & import("react").RefAttributes<HTMLElement>>;
+export default Alert;

package/dist/esm/components/alert/index.d.ts

@@ -0,0 +1 @@
+export { default, type AlertProps } from './Alert';

package/dist/esm/components/banner/Banner.css.d.ts

@@ -0,0 +1,21 @@
+export declare const banner: import("@vanilla-extract/recipes").RuntimeFn<{
+    status: {
+        info: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+        success: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+        warning: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+        error: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+    };
+}>;
+export declare const icon: string;

package/dist/esm/components/banner/Banner.d.ts

@@ -0,0 +1,12 @@
+import { type BoxProps } from '@vinyasa/layout/box';
+import { type ReactNode } from 'react';
+import { type Status } from '../../status';
+export type BannerProps = Omit<BoxProps, 'children'> & {
+    status?: Status;
+    children?: ReactNode;
+};
+declare const Banner: import("react").ForwardRefExoticComponent<Omit<BoxProps, "children"> & {
+    status?: Status;
+    children?: ReactNode;
+} & import("react").RefAttributes<HTMLElement>>;
+export default Banner;

package/dist/esm/components/banner/index.d.ts

@@ -0,0 +1 @@
+export { default, type BannerProps } from './Banner';

package/dist/esm/components/circular-progress/CircularProgress.css.d.ts

@@ -0,0 +1,4 @@
+export declare const svg: string;
+export declare const indeterminate: string;
+export declare const track: string;
+export declare const fill: string;

package/dist/esm/components/circular-progress/CircularProgress.d.ts

@@ -0,0 +1,17 @@
+import { type ComponentPropsWithoutRef } from 'react';
+import { type SpacingProps } from '../../spacing';
+export type CircularProgressProps = Omit<ComponentPropsWithoutRef<'svg'>, 'children'> & SpacingProps & {
+    /** Current progress, 0-max. Omit for an indeterminate spinning ring. */
+    value?: number;
+    max?: number;
+    size?: number;
+    strokeWidth?: number;
+};
+declare const CircularProgress: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").SVGProps<SVGSVGElement>, "ref">, "children"> & SpacingProps & {
+    /** Current progress, 0-max. Omit for an indeterminate spinning ring. */
+    value?: number;
+    max?: number;
+    size?: number;
+    strokeWidth?: number;
+} & import("react").RefAttributes<SVGSVGElement>>;
+export default CircularProgress;

package/dist/esm/components/circular-progress/index.d.ts

@@ -0,0 +1 @@
+export { default, type CircularProgressProps } from './CircularProgress';

package/dist/esm/components/empty-state/EmptyState.css.d.ts

@@ -0,0 +1 @@
+export declare const iconWrapper: string;

package/dist/esm/components/empty-state/EmptyState.d.ts

@@ -0,0 +1,15 @@
+import { type CenterProps } from '@vinyasa/layout';
+import { type ReactNode } from 'react';
+export type EmptyStateProps = Omit<CenterProps, 'children'> & {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+};
+declare const EmptyState: import("react").ForwardRefExoticComponent<Omit<CenterProps, "children"> & {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+} & import("react").RefAttributes<HTMLElement>>;
+export default EmptyState;

package/dist/esm/components/empty-state/index.d.ts

@@ -0,0 +1 @@
+export { default, type EmptyStateProps } from './EmptyState';

package/dist/esm/components/error-boundary/ErrorBoundary.d.ts

@@ -0,0 +1,32 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+export interface ErrorBoundaryFallbackProps {
+    error: Error;
+    resetErrorBoundary: () => void;
+}
+export interface ErrorBoundaryProps {
+    children: ReactNode;
+    /**
+     * A plain node, or a render function receiving the caught error and a
+     * `resetErrorBoundary` callback — same shape as the `react-error-boundary`
+     * package's `fallbackRender`, the de facto standard API for this.
+     * Defaults to an EmptyState with a "Try again" action wired to reset.
+     */
+    fallback?: ReactNode | ((props: ErrorBoundaryFallbackProps) => ReactNode);
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /** Called after the boundary resets, before children re-render. */
+    onReset?: () => void;
+    /** When any value in this array changes, the boundary resets automatically. */
+    resetKeys?: unknown[];
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
+    reset: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export default ErrorBoundary;

package/dist/esm/components/error-boundary/index.d.ts

@@ -0,0 +1 @@
+export { default, type ErrorBoundaryFallbackProps, type ErrorBoundaryProps } from './ErrorBoundary';

package/dist/esm/components/inline-message/InlineMessage.css.d.ts

@@ -0,0 +1,17 @@
+export declare const inlineMessage: import("@vanilla-extract/recipes").RuntimeFn<{
+    status: {
+        info: {
+            color: `var(--${string})`;
+        };
+        success: {
+            color: `var(--${string})`;
+        };
+        warning: {
+            color: `var(--${string})`;
+        };
+        error: {
+            color: `var(--${string})`;
+        };
+    };
+}>;
+export declare const icon: string;

package/dist/esm/components/inline-message/InlineMessage.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentPropsWithoutRef } from 'react';
+import { type SpacingProps } from '../../spacing';
+import { type Status } from '../../status';
+export type InlineMessageProps = ComponentPropsWithoutRef<'span'> & SpacingProps & {
+    status?: Status;
+};
+declare const InlineMessage: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & SpacingProps & {
+    status?: Status;
+} & import("react").RefAttributes<HTMLSpanElement>>;
+export default InlineMessage;

package/dist/esm/components/inline-message/index.d.ts

@@ -0,0 +1 @@
+export { default, type InlineMessageProps } from './InlineMessage';

package/dist/esm/components/loading-overlay/LoadingOverlay.css.d.ts

@@ -0,0 +1,3 @@
+export declare const wrapper: string;
+export declare const overlay: string;
+export declare const backdrop: string;