varsel 0.5.1 → 0.5.4

package/dist/core/animations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations.d.ts","sourceRoot":"","sources":["../../src/lib/core/animations.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC5B,kDAAkD;;IAElD,iDAAiD;;IAEjD,iEAAiE;;IAEjE,6EAA6E;;IAE7E,yEAAyE;;IAEzE,qEAAqE;;IAErE,+DAA+D;;IAE/D,6DAA6D;;IAE7D,wCAAwC;;IAExC,2DAA2D;;IAE3D,2CAA2C;;CAElC,CAAC"}

package/dist/core/animations.js

@@ -0,0 +1,28 @@
+/**
+ * Global configuration constants for toast animations and stacking behavior.
+ * These values control timing, spacing, scaling, and easing of toast transitions.
+ */
+export const ANIMATION_CONFIG = {
+    /** Duration of the entry animation in seconds. */
+    ENTER_DURATION: 0.75,
+    /** Duration of the exit animation in seconds. */
+    EXIT_DURATION: 0.75,
+    /** Duration of the stack reorganization animation in seconds. */
+    STACK_DURATION: 0.75,
+    /** Vertical offset (in pixels) between stacked toasts in collapsed state. */
+    STACK_OFFSET: 16,
+    /** Vertical gap (in pixels) between toasts in expanded (hover) state. */
+    EXPANDED_GAP: 12,
+    /** Scale reduction factor for each subsequent toast in the stack. */
+    SCALE_FACTOR: 0.04,
+    /** Minimum scale value for the furthest toast in the stack. */
+    MIN_SCALE: 0.92,
+    /** Maximum number of toasts visible in the stack at once. */
+    MAX_VISIBLE_TOASTS: 3,
+    /** Base z-index for the toast layer. */
+    Z_INDEX_BASE: 50,
+    /** Default cubic-bezier easing function for animations. */
+    EASING_DEFAULT: "var(--ease-vs-toast)",
+    /** Easing function for exit animations. */
+    EASING_EXIT: "var(--ease-vs-toast)",
+};

package/dist/core/positions.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Configuration for initial animation states based on toast position.
+ * Defines the starting transform values (x, y) for entering and exiting toasts.
+ */
+export declare const POSITION_CONFIGS: {
+    readonly "top-left": {
+        readonly animateIn: {
+            readonly x: -100;
+            readonly y: -20;
+        };
+        readonly animateOut: {
+            readonly x: -100;
+            readonly y: -100;
+        };
+    };
+    readonly "top-center": {
+        readonly animateIn: {
+            readonly x: 0;
+            readonly y: -100;
+        };
+        readonly animateOut: {
+            readonly x: 0;
+            readonly y: -100;
+        };
+    };
+    readonly "top-right": {
+        readonly animateIn: {
+            readonly x: 100;
+            readonly y: -20;
+        };
+        readonly animateOut: {
+            readonly x: 100;
+            readonly y: -100;
+        };
+    };
+    readonly "bottom-left": {
+        readonly animateIn: {
+            readonly x: -100;
+            readonly y: 20;
+        };
+        readonly animateOut: {
+            readonly x: -100;
+            readonly y: 100;
+        };
+    };
+    readonly "bottom-center": {
+        readonly animateIn: {
+            readonly x: 0;
+            readonly y: 100;
+        };
+        readonly animateOut: {
+            readonly x: 0;
+            readonly y: 100;
+        };
+    };
+    readonly "bottom-right": {
+        readonly animateIn: {
+            readonly x: 100;
+            readonly y: 20;
+        };
+        readonly animateOut: {
+            readonly x: 100;
+            readonly y: 100;
+        };
+    };
+};
+/**
+ * Available positions for the toaster on the screen.
+ */
+export type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+//# sourceMappingURL=positions.d.ts.map

package/dist/core/positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positions.d.ts","sourceRoot":"","sources":["../../src/lib/core/positions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBnB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,aAAa,GACtB,UAAU,GACV,YAAY,GACZ,WAAW,GACX,aAAa,GACb,eAAe,GACf,cAAc,CAAC"}

package/dist/core/positions.js

@@ -0,0 +1,30 @@
+/**
+ * Configuration for initial animation states based on toast position.
+ * Defines the starting transform values (x, y) for entering and exiting toasts.
+ */
+export const POSITION_CONFIGS = {
+    "top-left": {
+        animateIn: { x: -100, y: -20 },
+        animateOut: { x: -100, y: -100 },
+    },
+    "top-center": {
+        animateIn: { x: 0, y: -100 },
+        animateOut: { x: 0, y: -100 },
+    },
+    "top-right": {
+        animateIn: { x: 100, y: -20 },
+        animateOut: { x: 100, y: -100 },
+    },
+    "bottom-left": {
+        animateIn: { x: -100, y: 20 },
+        animateOut: { x: -100, y: 100 },
+    },
+    "bottom-center": {
+        animateIn: { x: 0, y: 100 },
+        animateOut: { x: 0, y: 100 },
+    },
+    "bottom-right": {
+        animateIn: { x: 100, y: 20 },
+        animateOut: { x: 100, y: 100 },
+    },
+};

package/dist/core/swipe.d.ts

@@ -0,0 +1,20 @@
+import type { ToastPosition } from "./positions";
+/** Directions in which a toast can be swiped to dismiss. */
+export type SwipeDirection = "top" | "bottom" | "left" | "right";
+/** Axes along which swipe gestures are tracked. */
+export type SwipeAxis = "x" | "y";
+/** Minimum pixel distance required to trigger a swipe dismissal. */
+export declare const SWIPE_DISMISS_THRESHOLD = 45;
+/** Minimum velocity (pixels/ms) required to trigger a swipe dismissal. */
+export declare const SWIPE_DISMISS_VELOCITY = 0.11;
+/** Distance in pixels to move the toast during the exit animation after a swipe. */
+export declare const SWIPE_EXIT_DISTANCE = 600;
+/**
+ * Determines the allowed swipe directions based on the toast's position.
+ * For example, a "top-right" toast can be swiped "top" or "right".
+ *
+ * @param position - The toast's position on screen.
+ * @returns An array of allowed swipe directions.
+ */
+export declare const getDefaultSwipeDirections: (position?: ToastPosition | null) => SwipeDirection[];
+//# sourceMappingURL=swipe.d.ts.map

package/dist/core/swipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipe.d.ts","sourceRoot":"","sources":["../../src/lib/core/swipe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,4DAA4D;AAC5D,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;AACjE,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,CAAC;AAElC,oEAAoE;AACpE,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,0EAA0E;AAC1E,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GACrC,WAAW,aAAa,GAAG,IAAI,KAC7B,cAAc,EAwBhB,CAAC"}

package/dist/core/swipe.js

@@ -0,0 +1,30 @@
+/** Minimum pixel distance required to trigger a swipe dismissal. */
+export const SWIPE_DISMISS_THRESHOLD = 45;
+/** Minimum velocity (pixels/ms) required to trigger a swipe dismissal. */
+export const SWIPE_DISMISS_VELOCITY = 0.11;
+/** Distance in pixels to move the toast during the exit animation after a swipe. */
+export const SWIPE_EXIT_DISTANCE = 600;
+/**
+ * Determines the allowed swipe directions based on the toast's position.
+ * For example, a "top-right" toast can be swiped "top" or "right".
+ *
+ * @param position - The toast's position on screen.
+ * @returns An array of allowed swipe directions.
+ */
+export const getDefaultSwipeDirections = (position) => {
+    if (!position) {
+        return ["top", "bottom", "left", "right"];
+    }
+    const [vertical, horizontal] = position.split("-");
+    const directions = [];
+    if (vertical === "top" || vertical === "bottom") {
+        directions.push(vertical);
+    }
+    if (horizontal === "left" || horizontal === "right") {
+        directions.push(horizontal);
+    }
+    if (directions.length === 0) {
+        directions.push("top", "bottom");
+    }
+    return directions;
+};

package/dist/core/toast-factory.d.ts

@@ -0,0 +1,3 @@
+import type { ToastInvoker } from "./types";
+export declare const toast: ToastInvoker;
+//# sourceMappingURL=toast-factory.d.ts.map

package/dist/core/toast-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast-factory.d.ts","sourceRoot":"","sources":["../../src/lib/core/toast-factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGX,YAAY,EAEZ,MAAM,SAAS,CAAC;AAuLjB,eAAO,MAAM,KAAK,cAAc,CAAC"}

package/dist/core/toast-factory.js

@@ -0,0 +1,144 @@
+import { toastState } from "./toast-state";
+/**
+ * Helper to normalize string input into a ToastData object.
+ */
+const normalizeToastData = (data) => {
+    if (typeof data === "string") {
+        return { description: data };
+    }
+    return data;
+};
+/**
+ * Resolves the state of a promise-based toast (success or error) into actual toast data.
+ */
+const resolvePromiseState = async (value, state) => {
+    const resolvedValue = typeof state === "function" ? await state(value) : await state;
+    return normalizeToastData(resolvedValue);
+};
+const getPromiseFallbackDescription = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return "An unknown error occurred while updating the notification.";
+};
+/**
+ * The main entry point for creating toasts.
+ * @param data - Toast configuration object or description string.
+ * @returns The ID of the created toast.
+ */
+const createToast = ((data) => {
+    return toastState.add(normalizeToastData(data));
+});
+/**
+ * Creates a success variant toast.
+ */
+createToast.success = (data) => {
+    if (typeof data === "string") {
+        return toastState.add({ description: data, variant: "success" });
+    }
+    return toastState.add({ ...data, variant: "success" });
+};
+/**
+ * Creates a warning variant toast.
+ */
+createToast.warning = (data) => {
+    if (typeof data === "string") {
+        return toastState.add({ description: data, variant: "warning" });
+    }
+    return toastState.add({ ...data, variant: "warning" });
+};
+/**
+ * Creates an info variant toast.
+ */
+createToast.info = (data) => {
+    if (typeof data === "string") {
+        return toastState.add({ description: data, variant: "info" });
+    }
+    return toastState.add({ ...data, variant: "info" });
+};
+/**
+ * Creates an error (destructive) variant toast.
+ */
+createToast.error = (data) => {
+    if (typeof data === "string") {
+        return toastState.add({ description: data, variant: "destructive" });
+    }
+    return toastState.add({ ...data, variant: "destructive" });
+};
+/**
+ * Creates a custom component toast.
+ * @param component - The Svelte component to render.
+ * @param options - Additional options and props for the component.
+ */
+createToast.custom = (component, // Type inferred from ToastInvoker
+options) => {
+    return toastState.add({
+        ...(options ?? {}),
+        component: component,
+        variant: "custom",
+    });
+};
+/**
+ * Creates a toast that tracks a promise's lifecycle.
+ * Updates automatically from loading -> success/error.
+ *
+ * @param promise - The promise to observe.
+ * @param options - Configuration for loading, success, and error states.
+ * @returns The ID of the toast.
+ */
+createToast.promise = (promise, options) => {
+    const loadingData = normalizeToastData(options.loading);
+    const toastId = toastState.add({
+        ...loadingData,
+        duration: loadingData.duration ?? 0,
+        isLoading: true,
+        showClose: loadingData.showClose ?? true,
+    });
+    const handleResult = async (state, value, defaultVariant) => {
+        const payload = await resolvePromiseState(value, state);
+        toastState.update(toastId, {
+            ...payload,
+            isLoading: false,
+            duration: payload.duration,
+            variant: payload.variant ?? defaultVariant,
+            showClose: payload.showClose ?? true,
+        });
+    };
+    const applyPromiseFallback = (error) => {
+        toastState.update(toastId, {
+            title: "Operation failed",
+            description: getPromiseFallbackDescription(error),
+            variant: "destructive",
+            isLoading: false,
+            showClose: true,
+            duration: 5000,
+        });
+    };
+    void Promise.resolve(promise)
+        .then((value) => {
+        return handleResult(options.success, value, "success");
+    })
+        .catch((error) => {
+        return handleResult(options.error, error, "destructive");
+    })
+        .catch((error) => {
+        applyPromiseFallback(error);
+    });
+    return toastId;
+};
+/**
+ * Dismisses a toast by ID.
+ */
+createToast.dismiss = (id) => {
+    toastState.update(id, { shouldClose: true });
+};
+/**
+ * Dismisses all active toasts.
+ */
+createToast.dismissAll = () => {
+    toastState.dismissAll();
+};
+export const toast = createToast;

package/dist/core/toast-state.d.ts

@@ -0,0 +1,49 @@
+import type { ToastData, ToastSubscriber } from "./types";
+/**
+ * Manages the global state of toast notifications.
+ * Implements a singleton pattern with a subscription mechanism.
+ */
+declare class ToastState {
+    private toasts;
+    private subscribers;
+    private idCounter;
+    /**
+     * Subscribes to changes in the toast list.
+     * @param callback - Function to be called when the toast list updates.
+     * @returns A cleanup function to unsubscribe.
+     */
+    subscribe(callback: ToastSubscriber): () => void;
+    private notify;
+    private generateId;
+    /**
+     * Adds a new toast to the state.
+     * @param data - The toast configuration (without ID).
+     * @returns The generated ID of the new toast.
+     */
+    add(data: Omit<ToastData, "id">): string;
+    /**
+     * Removes a toast from the state by its ID.
+     * @param id - The ID of the toast to remove.
+     */
+    remove(id: string): void;
+    /**
+     * Updates an existing toast's data.
+     * @param id - The ID of the toast to update.
+     * @param data - Partial data to merge into the existing toast.
+     */
+    update(id: string, data: Partial<ToastData>): void;
+    /**
+     * Marks all active toasts for dismissal.
+     * Triggers the closing animation by setting `shouldClose` to true.
+     */
+    dismissAll(): void;
+    /**
+     * Returns the current list of active toasts.
+     * @returns A copy of the toast array.
+     */
+    getToasts(): ToastData[];
+}
+/** Global singleton instance of the toast state. */
+export declare const toastState: ToastState;
+export { ToastState };
+//# sourceMappingURL=toast-state.d.ts.map

package/dist/core/toast-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast-state.d.ts","sourceRoot":"","sources":["../../src/lib/core/toast-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1D;;;GAGG;AACH,cAAM,UAAU;IACf,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,SAAS,CAAK;IAEtB;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAOhD,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,UAAU;IAIlB;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,MAAM;IASxC;;;OAGG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKxB;;;;OAIG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAOlD;;;OAGG;IACH,UAAU,IAAI,IAAI;IASlB;;;OAGG;IACH,SAAS,IAAI,SAAS,EAAE;CAGxB;AAED,oDAAoD;AACpD,eAAO,MAAM,UAAU,YAAmB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/core/toast-state.js

@@ -0,0 +1,80 @@
+/**
+ * Manages the global state of toast notifications.
+ * Implements a singleton pattern with a subscription mechanism.
+ */
+class ToastState {
+    toasts = [];
+    subscribers = new Set();
+    idCounter = 0;
+    /**
+     * Subscribes to changes in the toast list.
+     * @param callback - Function to be called when the toast list updates.
+     * @returns A cleanup function to unsubscribe.
+     */
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    notify() {
+        this.subscribers.forEach((callback) => {
+            callback([...this.toasts]);
+        });
+    }
+    generateId() {
+        return `toast-${Date.now()}-${++this.idCounter}`;
+    }
+    /**
+     * Adds a new toast to the state.
+     * @param data - The toast configuration (without ID).
+     * @returns The generated ID of the new toast.
+     */
+    add(data) {
+        const id = this.generateId();
+        const newToast = { ...data, id };
+        // Add new toasts to the beginning of the array (stack LIFO visually for some positions, logic handled in manager)
+        this.toasts = [newToast, ...this.toasts];
+        this.notify();
+        return id;
+    }
+    /**
+     * Removes a toast from the state by its ID.
+     * @param id - The ID of the toast to remove.
+     */
+    remove(id) {
+        this.toasts = this.toasts.filter((toast) => toast.id !== id);
+        this.notify();
+    }
+    /**
+     * Updates an existing toast's data.
+     * @param id - The ID of the toast to update.
+     * @param data - Partial data to merge into the existing toast.
+     */
+    update(id, data) {
+        this.toasts = this.toasts.map((toast) => toast.id === id ? { ...toast, ...data } : toast);
+        this.notify();
+    }
+    /**
+     * Marks all active toasts for dismissal.
+     * Triggers the closing animation by setting `shouldClose` to true.
+     */
+    dismissAll() {
+        this.toasts = this.toasts.map((toast) => ({
+            ...toast,
+            shouldClose: true,
+            duration: 0,
+        }));
+        this.notify();
+    }
+    /**
+     * Returns the current list of active toasts.
+     * @returns A copy of the toast array.
+     */
+    getToasts() {
+        return [...this.toasts];
+    }
+}
+/** Global singleton instance of the toast state. */
+export const toastState = new ToastState();
+export { ToastState };

package/dist/core/toaster-instances.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Manages unique instances of the Toaster component to prevent conflicts.
+ * Ensures that if multiple Toasters are rendered, only one (the first or primary) is active.
+ */
+declare class ToasterInstanceManager {
+    private activeInstanceId;
+    private instanceCounter;
+    private instanceIds;
+    /**
+     * Registers a new toaster instance.
+     * @returns A unique instance ID.
+     */
+    registerInstance(): string;
+    /**
+     * Unregisters an instance, potentially freeing up the active slot.
+     * @param instanceId - The ID of the instance to unregister.
+     */
+    unregisterInstance(instanceId: string): void;
+    /**
+     * Checks if the given instance is the currently active one.
+     * @param instanceId - The ID to check.
+     * @returns True if active, false otherwise.
+     */
+    isActiveInstance(instanceId: string): boolean;
+}
+export declare const toasterInstanceManager: ToasterInstanceManager;
+export { ToasterInstanceManager };
+//# sourceMappingURL=toaster-instances.d.ts.map

package/dist/core/toaster-instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toaster-instances.d.ts","sourceRoot":"","sources":["../../src/lib/core/toaster-instances.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAM,sBAAsB;IAC3B,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,WAAW,CAAgB;IAEnC;;;OAGG;IACH,gBAAgB,IAAI,MAAM;IAY1B;;;OAGG;IACH,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAY5C;;;;OAIG;IACH,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;CAG7C;AAED,eAAO,MAAM,sBAAsB,wBAA+B,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/core/toaster-instances.js

@@ -0,0 +1,46 @@
+/**
+ * Manages unique instances of the Toaster component to prevent conflicts.
+ * Ensures that if multiple Toasters are rendered, only one (the first or primary) is active.
+ */
+class ToasterInstanceManager {
+    activeInstanceId = null;
+    instanceCounter = 0;
+    instanceIds = [];
+    /**
+     * Registers a new toaster instance.
+     * @returns A unique instance ID.
+     */
+    registerInstance() {
+        const instanceId = `toaster-${++this.instanceCounter}`;
+        this.instanceIds.push(instanceId);
+        if (!this.activeInstanceId ||
+            !this.instanceIds.includes(this.activeInstanceId)) {
+            this.activeInstanceId = instanceId;
+        }
+        return instanceId;
+    }
+    /**
+     * Unregisters an instance, potentially freeing up the active slot.
+     * @param instanceId - The ID of the instance to unregister.
+     */
+    unregisterInstance(instanceId) {
+        this.instanceIds = this.instanceIds.filter((id) => id !== instanceId);
+        if (this.activeInstanceId === instanceId) {
+            this.activeInstanceId = this.instanceIds[0] ?? null;
+        }
+        else if (this.activeInstanceId &&
+            !this.instanceIds.includes(this.activeInstanceId)) {
+            this.activeInstanceId = this.instanceIds[0] ?? null;
+        }
+    }
+    /**
+     * Checks if the given instance is the currently active one.
+     * @param instanceId - The ID to check.
+     * @returns True if active, false otherwise.
+     */
+    isActiveInstance(instanceId) {
+        return this.activeInstanceId === instanceId;
+    }
+}
+export const toasterInstanceManager = new ToasterInstanceManager();
+export { ToasterInstanceManager };