@pathscale/ui 1.2.0 → 1.2.2

package/dist/components/toast/Toast.classes.d.ts

@@ -0,0 +1,67 @@
+export declare const CLASSES: {
+    readonly Provider: {
+        readonly base: "toast-region";
+        readonly stack: "toast-region__stack";
+        readonly item: {
+            readonly base: "toast-region__item";
+            readonly placement: {
+                readonly bottom: "toast-region__item--bottom";
+                readonly bottomStart: "toast-region__item--bottom-start";
+                readonly bottomEnd: "toast-region__item--bottom-end";
+                readonly top: "toast-region__item--top";
+                readonly topStart: "toast-region__item--top-start";
+                readonly topEnd: "toast-region__item--top-end";
+            };
+            readonly state: {
+                readonly hidden: "toast-region__item--hidden";
+            };
+        };
+        readonly placement: {
+            readonly bottom: "toast-region--bottom";
+            readonly bottomStart: "toast-region--bottom-start";
+            readonly bottomEnd: "toast-region--bottom-end";
+            readonly top: "toast-region--top";
+            readonly topStart: "toast-region--top-start";
+            readonly topEnd: "toast-region--top-end";
+        };
+    };
+    readonly Item: {
+        readonly base: "toast";
+        readonly variant: {
+            readonly default: "toast--default";
+            readonly accent: "toast--accent";
+            readonly success: "toast--success";
+            readonly warning: "toast--warning";
+            readonly danger: "toast--danger";
+        };
+        readonly state: {
+            readonly frontmost: "toast--frontmost";
+            readonly hidden: "toast--hidden";
+            readonly entering: "toast--entering";
+            readonly exiting: "toast--exiting";
+        };
+    };
+    readonly Content: {
+        readonly base: "toast__content";
+    };
+    readonly Indicator: {
+        readonly base: "toast__indicator";
+        readonly icon: "toast__icon";
+    };
+    readonly Spinner: {
+        readonly base: "toast__spinner";
+    };
+    readonly Title: {
+        readonly base: "toast__title";
+    };
+    readonly Description: {
+        readonly base: "toast__description";
+    };
+    readonly Action: {
+        readonly base: "toast__action";
+    };
+    readonly Close: {
+        readonly base: "toast__close";
+        readonly icon: "toast__close-icon";
+    };
+};

package/dist/components/toast/Toast.classes.js

@@ -0,0 +1,68 @@
+const CLASSES = {
+    Provider: {
+        base: "toast-region",
+        stack: "toast-region__stack",
+        item: {
+            base: "toast-region__item",
+            placement: {
+                bottom: "toast-region__item--bottom",
+                bottomStart: "toast-region__item--bottom-start",
+                bottomEnd: "toast-region__item--bottom-end",
+                top: "toast-region__item--top",
+                topStart: "toast-region__item--top-start",
+                topEnd: "toast-region__item--top-end"
+            },
+            state: {
+                hidden: "toast-region__item--hidden"
+            }
+        },
+        placement: {
+            bottom: "toast-region--bottom",
+            bottomStart: "toast-region--bottom-start",
+            bottomEnd: "toast-region--bottom-end",
+            top: "toast-region--top",
+            topStart: "toast-region--top-start",
+            topEnd: "toast-region--top-end"
+        }
+    },
+    Item: {
+        base: "toast",
+        variant: {
+            default: "toast--default",
+            accent: "toast--accent",
+            success: "toast--success",
+            warning: "toast--warning",
+            danger: "toast--danger"
+        },
+        state: {
+            frontmost: "toast--frontmost",
+            hidden: "toast--hidden",
+            entering: "toast--entering",
+            exiting: "toast--exiting"
+        }
+    },
+    Content: {
+        base: "toast__content"
+    },
+    Indicator: {
+        base: "toast__indicator",
+        icon: "toast__icon"
+    },
+    Spinner: {
+        base: "toast__spinner"
+    },
+    Title: {
+        base: "toast__title"
+    },
+    Description: {
+        base: "toast__description"
+    },
+    Action: {
+        base: "toast__action"
+    },
+    Close: {
+        base: "toast__close",
+        icon: "toast__close-icon"
+    }
+};
+export { CLASSES };

package/dist/components/toast/Toast.css

@@ -0,0 +1,344 @@
+@layer components {
+  .toast-region {
+    position: fixed;
+    z-index: var(--z-overlay, 70);
+    width: min(calc(100vw - 2rem), var(--toast-width, 28.75rem));
+    pointer-events: none;
+    outline: none;
+  }
+
+  .toast-region--bottom {
+    bottom: 1rem;
+    left: 50%;
+    transform: translateX(-50%);
+  }
+
+  .toast-region--bottom-start {
+    left: 1rem;
+    bottom: 1rem;
+  }
+
+  .toast-region--bottom-end {
+    right: 1rem;
+    bottom: 1rem;
+  }
+
+  .toast-region--top {
+    top: 1rem;
+    left: 50%;
+    transform: translateX(-50%);
+  }
+
+  .toast-region--top-start {
+    top: 1rem;
+    left: 1rem;
+  }
+
+  .toast-region--top-end {
+    top: 1rem;
+    right: 1rem;
+  }
+
+  .toast-region:focus-visible,
+  .toast-region[data-focus-visible="true"] {
+    outline: 2px solid var(--color-accent);
+    outline-offset: 2px;
+  }
+
+  .toast-region__stack {
+    position: relative;
+    width: 100%;
+    min-height: 0.125rem;
+  }
+
+  .toast-region__item {
+    position: absolute;
+    left: 0;
+    right: 0;
+    transition:
+      transform 200ms var(--ease-out, ease),
+      opacity 200ms var(--ease-out, ease);
+    will-change: transform, opacity;
+  }
+
+  .toast-region__item--bottom,
+  .toast-region__item--bottom-start,
+  .toast-region__item--bottom-end {
+    bottom: 0;
+  }
+
+  .toast-region__item--top,
+  .toast-region__item--top-start,
+  .toast-region__item--top-end {
+    top: 0;
+  }
+
+  .toast-region__item--hidden {
+    opacity: 0;
+    pointer-events: none;
+  }
+
+  .toast {
+    pointer-events: auto;
+    display: flex;
+    flex-direction: row;
+    align-items: flex-start;
+    gap: 0.5rem;
+    width: 100%;
+    border-radius: 1.5rem;
+    padding: 0.75rem 1rem;
+    background-color: var(--color-overlay, var(--color-base-100));
+    color: var(--color-overlay-foreground, var(--color-base-content));
+    box-shadow: var(
+      --shadow-overlay,
+      0 24px 48px color-mix(in oklab, black 24%, transparent)
+    );
+  }
+
+  .toast--hidden {
+    opacity: 0;
+    pointer-events: none;
+  }
+
+  .toast:not(.toast--frontmost) {
+    pointer-events: none;
+    height: var(--toast-front-height, auto);
+    overflow: hidden;
+  }
+
+  .toast:not(.toast--frontmost) .toast__close {
+    opacity: 0;
+    pointer-events: none;
+  }
+
+  .toast--entering {
+    animation-duration: 220ms;
+    animation-timing-function: var(--ease-out, ease);
+    animation-fill-mode: both;
+  }
+
+  .toast-region__item--bottom .toast--entering,
+  .toast-region__item--bottom-start .toast--entering,
+  .toast-region__item--bottom-end .toast--entering {
+    animation-name: toast-slide-bottom-in;
+  }
+
+  .toast-region__item--top .toast--entering,
+  .toast-region__item--top-start .toast--entering,
+  .toast-region__item--top-end .toast--entering {
+    animation-name: toast-slide-top-in;
+  }
+
+  .toast--exiting {
+    pointer-events: none;
+    animation-duration: 220ms;
+    animation-timing-function: var(--ease-out, ease);
+    animation-fill-mode: both;
+  }
+
+  .toast-region__item--bottom .toast--exiting,
+  .toast-region__item--bottom-start .toast--exiting,
+  .toast-region__item--bottom-end .toast--exiting {
+    animation-name: toast-slide-bottom-out;
+  }
+
+  .toast-region__item--top .toast--exiting,
+  .toast-region__item--top-start .toast--exiting,
+  .toast-region__item--top-end .toast--exiting {
+    animation-name: toast-slide-top-out;
+  }
+
+  .toast__content {
+    display: flex;
+    flex: 1;
+    min-width: 0;
+    flex-direction: column;
+    gap: 0.125rem;
+    align-items: flex-start;
+  }
+
+  .toast__indicator {
+    display: inline-flex;
+    width: 1.5rem;
+    height: 1.5rem;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    color: inherit;
+    user-select: none;
+    margin-top: 0.125rem;
+  }
+
+  .toast__icon {
+    width: 1rem;
+    height: 1rem;
+    flex-shrink: 0;
+    pointer-events: none;
+  }
+
+  .toast__spinner {
+    width: 1rem;
+    height: 1rem;
+    border-radius: 9999px;
+    border: 2px solid currentColor;
+    border-top-color: transparent;
+    animation: toast-spinner 600ms linear infinite;
+  }
+
+  .toast__title {
+    margin: 0;
+    font-size: 0.875rem;
+    font-weight: 600;
+    line-height: 1.25rem;
+    color: inherit;
+  }
+
+  .toast__description {
+    margin: 0;
+    font-size: 0.8125rem;
+    line-height: 1.2rem;
+    color: color-mix(in oklab, currentColor 74%, transparent);
+  }
+
+  .toast__action {
+    margin-top: 0.5rem;
+  }
+
+  .toast__close {
+    margin-top: 0.125rem;
+    opacity: 0;
+    background-color: transparent;
+    transition: opacity 150ms var(--ease-out, ease);
+  }
+
+  .toast__close-icon {
+    width: 0.875rem;
+    height: 0.875rem;
+    flex-shrink: 0;
+    pointer-events: none;
+  }
+
+  .toast--frontmost:hover .toast__close,
+  .toast--frontmost .toast__close:focus-visible,
+  .toast--frontmost .toast__close[data-focus-visible="true"] {
+    opacity: 1;
+  }
+
+  .toast--accent {
+    color: var(--color-accent);
+  }
+
+  .toast--success {
+    color: var(--color-success);
+  }
+
+  .toast--warning {
+    color: var(--color-warning);
+  }
+
+  .toast--danger {
+    color: var(--color-error);
+  }
+
+  .toast--default .toast__title,
+  .toast--default .toast__description {
+    color: var(--color-overlay-foreground, var(--color-base-content));
+  }
+
+  .toast--default .toast__indicator {
+    color: var(--color-overlay-foreground, var(--color-base-content));
+  }
+
+  .toast--default .toast__description {
+    color: color-mix(
+      in oklab,
+      var(--color-overlay-foreground, var(--color-base-content)) 72%,
+      transparent
+    );
+  }
+
+  @media (hover: hover) {
+    .toast--frontmost:hover .toast__close {
+      opacity: 1;
+      pointer-events: auto;
+    }
+  }
+
+  @media (max-width: 640px) {
+    .toast-region {
+      width: calc(100vw - 2rem);
+    }
+
+    .toast__close {
+      opacity: 1;
+      pointer-events: auto;
+    }
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .toast-region__item,
+    .toast__close {
+      transition: none;
+    }
+
+    .toast--entering,
+    .toast--exiting,
+    .toast__spinner {
+      animation: none;
+    }
+  }
+
+  @keyframes toast-slide-bottom-in {
+    from {
+      transform: translate3d(0, 0.75rem, 0);
+      opacity: 0;
+    }
+
+    to {
+      transform: translate3d(0, 0, 0);
+      opacity: 1;
+    }
+  }
+
+  @keyframes toast-slide-bottom-out {
+    from {
+      transform: translate3d(0, 0, 0);
+      opacity: 1;
+    }
+
+    to {
+      transform: translate3d(0, 0.75rem, 0);
+      opacity: 0;
+    }
+  }
+
+  @keyframes toast-slide-top-in {
+    from {
+      transform: translate3d(0, -0.75rem, 0);
+      opacity: 0;
+    }
+
+    to {
+      transform: translate3d(0, 0, 0);
+      opacity: 1;
+    }
+  }
+
+  @keyframes toast-slide-top-out {
+    from {
+      transform: translate3d(0, 0, 0);
+      opacity: 1;
+    }
+
+    to {
+      transform: translate3d(0, -0.75rem, 0);
+      opacity: 0;
+    }
+  }
+
+  @keyframes toast-spinner {
+    to {
+      transform: rotate(360deg);
+    }
+  }
+}

package/dist/components/toast/Toast.d.ts

@@ -1,22 +1,158 @@
-import "./toast.css";
-import { type JSX } from "solid-js";
+import "./Toast.css";
+import { type Component, type JSX, type ParentComponent } from "solid-js";
+import { type ButtonProps } from "../button";
+import { type CloseButtonProps } from "../close-button";
 import type { IComponentBaseProps } from "../types";
-declare const horizontalOptions: {
-    readonly start: "toast-start";
-    readonly center: "toast-center";
-    readonly end: "toast-end";
-};
-declare const verticalOptions: {
-    readonly top: "toast-top";
-    readonly middle: "toast-middle";
-    readonly bottom: "toast-bottom";
-};
-type ToastPosition = {
-    horizontal?: keyof typeof horizontalOptions;
-    vertical?: keyof typeof verticalOptions;
-};
-export type ToastProps = ToastPosition & IComponentBaseProps & {
-    max?: number;
-} & Omit<JSX.HTMLAttributes<HTMLDivElement>, keyof ToastPosition | "max">;
-declare const Toast: (props: ToastProps) => JSX.Element;
+export declare const DEFAULT_GAP = 12;
+export declare const DEFAULT_MAX_VISIBLE_TOAST = 3;
+export declare const DEFAULT_SCALE_FACTOR = 0.05;
+export declare const DEFAULT_TOAST_TIMEOUT = 4000;
+export declare const DEFAULT_TOAST_WIDTH = 460;
+export type ToastPlacement = "bottom" | "bottom-start" | "bottom-end" | "top" | "top-start" | "top-end" | "bottom start" | "bottom end" | "top start" | "top end";
+export type ToastVariant = "default" | "accent" | "success" | "warning" | "danger" | "info" | "error";
+export type ToastActionProps = Omit<ButtonProps, "variant" | "size">;
+export interface ToastContentValue {
+    indicator?: JSX.Element;
+    title?: JSX.Element;
+    description?: JSX.Element;
+    variant?: ToastVariant;
+    actionProps?: ToastActionProps;
+    isLoading?: boolean;
+}
+export interface ToastQueueAddOptions {
+    key?: string;
+    timeout?: number;
+    onClose?: () => void;
+}
+export interface ToastQueueItem<T extends object = ToastContentValue> {
+    key: string;
+    content: T;
+    createdAt: number;
+    timeout: number;
+    isEntering: boolean;
+    isExiting: boolean;
+}
+export interface ToastQueueOptions {
+    maxVisibleToasts?: number;
+    exitDuration?: number;
+}
+export declare class ToastQueue<T extends object = ToastContentValue> {
+    private readonly readToasts;
+    private readonly setToasts;
+    private readonly listeners;
+    private readonly closeCallbacks;
+    private readonly timeoutMeta;
+    private readonly exitTimers;
+    readonly maxVisibleToasts?: number;
+    private paused;
+    private keyCounter;
+    private readonly exitDuration;
+    constructor(options?: ToastQueueOptions);
+    private emit;
+    private updateToasts;
+    private scheduleTimeout;
+    private clearTimeoutFor;
+    private clearExitTimerFor;
+    add(content: T, options?: ToastQueueAddOptions): string;
+    close(key: string): void;
+    remove(key: string, invokeOnClose?: boolean): void;
+    clear(invokeOnClose?: boolean): void;
+    pauseAll(): void;
+    resumeAll(): void;
+    subscribe(fn: () => void): () => void;
+    toasts(): ToastQueueItem<T>[];
+    get visibleToasts(): ToastQueueItem<T>[];
+    getQueue(): ToastQueue<T>;
+}
+export type ToastRootProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children" | "title"> & IComponentBaseProps & {
+    children?: JSX.Element;
+    title?: JSX.Element;
+    description?: JSX.Element;
+    variant?: ToastVariant;
+    indicator?: JSX.Element;
+    actionProps?: ToastActionProps;
+    isLoading?: boolean;
+    onClose?: () => void;
+    isFrontmost?: boolean;
+    isHidden?: boolean;
+    isEntering?: boolean;
+    isExiting?: boolean;
+};
+export type ToastContentProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element;
+};
+export type ToastIndicatorProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element;
+    variant?: ToastVariant;
+};
+export type ToastTitleProps = Omit<JSX.HTMLAttributes<HTMLParagraphElement>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element;
+};
+export type ToastDescriptionProps = Omit<JSX.HTMLAttributes<HTMLParagraphElement>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element;
+};
+export type ToastActionButtonProps = ToastActionProps;
+export type ToastCloseButtonProps = Omit<JSX.ButtonHTMLAttributes<HTMLButtonElement>, "children"> & Omit<CloseButtonProps, "children" | "startIcon" | "endIcon">;
+declare const ToastContent: ParentComponent<ToastContentProps>;
+declare const ToastIndicator: Component<ToastIndicatorProps>;
+declare const ToastTitle: ParentComponent<ToastTitleProps>;
+declare const ToastDescription: ParentComponent<ToastDescriptionProps>;
+declare const ToastActionButton: Component<ToastActionButtonProps>;
+declare const ToastCloseButton: Component<ToastCloseButtonProps>;
+declare const ToastRoot: ParentComponent<ToastRootProps>;
+export type ToastRenderFn = (toast: ToastQueueItem<ToastContentValue>, dismiss: () => void) => JSX.Element;
+export type ToastProviderProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element;
+    placement?: ToastPlacement;
+    queue?: ToastQueue<ToastContentValue> | null;
+    width?: number | string;
+    gap?: number;
+    maxVisibleToasts?: number;
+    scaleFactor?: number;
+    renderToast?: ToastRenderFn;
+};
+declare const ToastProvider: ParentComponent<ToastProviderProps>;
+export interface HeroUIToastOptions {
+    description?: JSX.Element;
+    indicator?: JSX.Element;
+    variant?: ToastVariant;
+    actionProps?: ToastActionProps;
+    isLoading?: boolean;
+    timeout?: number;
+    onClose?: () => void;
+}
+export interface ToastPromiseOptions<T = unknown> {
+    loading: JSX.Element;
+    success: ((data: T) => JSX.Element) | JSX.Element;
+    error: ((error: Error) => JSX.Element) | JSX.Element;
+}
+type ToastFunction = ((message: JSX.Element, options?: HeroUIToastOptions) => string) & {
+    success: (message: JSX.Element, options?: Omit<HeroUIToastOptions, "variant">) => string;
+    danger: (message: JSX.Element, options?: Omit<HeroUIToastOptions, "variant">) => string;
+    error: (message: JSX.Element, options?: Omit<HeroUIToastOptions, "variant">) => string;
+    info: (message: JSX.Element, options?: Omit<HeroUIToastOptions, "variant">) => string;
+    warning: (message: JSX.Element, options?: Omit<HeroUIToastOptions, "variant">) => string;
+    promise: <T>(promise: Promise<T> | (() => Promise<T>), options: ToastPromiseOptions<T>) => string;
+    close: (key: string) => void;
+    pauseAll: () => void;
+    resumeAll: () => void;
+    clear: () => void;
+    getQueue: () => ToastQueue<ToastContentValue>;
+};
+declare const toastQueue: ToastQueue<ToastContentValue>;
+declare const toast: ToastFunction;
+type ToastComponent = ParentComponent<ToastRootProps> & {
+    Provider: ParentComponent<ToastProviderProps>;
+    Content: ParentComponent<ToastContentProps>;
+    Indicator: Component<ToastIndicatorProps>;
+    Title: ParentComponent<ToastTitleProps>;
+    Description: ParentComponent<ToastDescriptionProps>;
+    ActionButton: Component<ToastActionButtonProps>;
+    CloseButton: Component<ToastCloseButtonProps>;
+    Queue: typeof ToastQueue;
+    toast: ToastFunction;
+};
+declare const Toast: ToastComponent;
 export default Toast;
+export { ToastRoot, ToastProvider, ToastContent, ToastIndicator, ToastTitle, ToastDescription, ToastActionButton, ToastCloseButton, toast, toastQueue, };
+export type { ToastFunction };