@dvcol/neo-svelte 1.1.2 → 1.2.0

package/dist/floating/notification/neo-notification-item.model.d.ts

@@ -0,0 +1,54 @@
+import type { NeoNotificationStackProps } from './neo-notification-stack.model.js';
+import type { NeoNotification, NeoNotificationQueued } from './neo-notification.model.js';
+import type { HTMLNeoBaseElement } from '../../utils/html-element.utils.js';
+export interface NeoNotificationItemProps<Tag extends keyof HTMLElementTagNameMap = 'li'> extends Omit<HTMLNeoBaseElement, 'children' | 'color'>, Pick<NeoNotification, 'restartOnTouch' | 'containerProps' | 'progressProps' | 'actionProps' | 'closeProps' | 'close' | 'loading' | 'progress' | 'elevation' | 'blur' | 'color' | 'rounded' | 'tinted' | 'filled' | 'borderless' | 'before' | 'after'> {
+    children?: NeoNotificationStackProps['children'];
+    ref?: HTMLElement;
+    hovered?: boolean;
+    focused?: boolean;
+    tag?: Tag | keyof HTMLElementTagNameMap;
+    index: number;
+    item: NeoNotificationQueued;
+    posinset: number;
+    setsize: number;
+    visible?: number;
+    expand?: boolean;
+    reverse?: boolean;
+    draggable?: NeoNotificationStackProps['draggable'];
+    swipeable?: NeoNotificationStackProps['swipeable'];
+    placement?: NeoNotificationStackProps['placement'];
+    threshold?: NeoNotificationStackProps['threshold'];
+    stagger?: NeoNotificationStackProps['stagger'];
+    /**
+     * If true, a notification from the stack has recently been swiped.
+     * This is used to prevent the item from being swiped again immediately after a swipe.
+     *
+     * @default false
+     */
+    swiped?: boolean;
+    onChange?: (payload: {
+        item: NeoNotificationQueued;
+        index: number;
+        hovered: boolean;
+        focused: boolean;
+        event: PointerEvent | FocusEvent;
+    }) => void;
+    onDrag?: (payload: {
+        item: NeoNotificationQueued;
+        index: number;
+        event: PointerEvent | WheelEvent;
+        initial: {
+            x: number;
+            y: number;
+        } | false;
+        offset: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+    onCancel?: (payload: {
+        item: NeoNotificationQueued;
+        index: number;
+        event: PointerEvent | WheelEvent | MouseEvent;
+    }) => void;
+}

package/dist/floating/notification/neo-notification-item.model.js

@@ -0,0 +1 @@
+export {};

package/dist/floating/notification/neo-notification-provider.model.d.ts

@@ -0,0 +1,78 @@
+import type { Snippet } from 'svelte';
+import type { SvelteMap } from 'svelte/reactivity';
+import type { NeoNotificationStackProps } from './neo-notification-stack.model.js';
+import type { NeoNotification, NeoNotificationDeQueued, NeoNotificationQueued } from './neo-notification.model.js';
+type NeoNotificationServices = SvelteMap<NeoNotificationStackService['id'], NeoNotificationStackService>;
+export interface NotificationProviderProps {
+    /**
+     * The children to render inside the notification provider.
+     */
+    children?: Snippet<[NeoNotificationServices]>;
+    /**
+     * Service map for notification stacks.
+     */
+    services?: NeoNotificationServices;
+    /**
+     * Optional notification stack properties.
+     * If set to `false`, no default stack will be created.
+     */
+    stack?: NeoNotificationStackProps | false;
+}
+export interface NeoNotificationStackService {
+    /**
+     * Unique identifier for the notification stack.
+     */
+    id: NeoNotificationStackProps['id'];
+    /**
+     * Adds a notification to the stack.
+     * @param notification - The notification to add.
+     * @returns A promise that resolves when the notification is processed.
+     */
+    add: (notification: NeoNotification) => NeoNotificationQueued;
+    /**
+     * Retrieves a notification from the stack by its ID.
+     * @param id - The Unique ID of the notification to retrieve.
+     */
+    get: (id: string) => NeoNotificationQueued | undefined;
+    /**
+     * Removes a notification from the stack by its ID.
+     * @param id - The Unique ID of the notification to remove.
+     */
+    remove: (id: string) => NeoNotificationDeQueued;
+    /**
+     * Updates an existing notification in the stack.
+     * @param id - The ID of the notification to update.
+     * @param update - The properties to update.
+     * @returns The updated notification, or undefined if not found.
+     */
+    update: (id: string, update: Omit<NeoNotification, 'id'>) => NeoNotificationQueued;
+    /**
+     * Pauses or resumes the notification stack.
+     * @param pause - If true, pauses the stack; if false, resumes it.
+     */
+    pause: (pause?: boolean) => void;
+    /**
+     * Restarts a notification in the stack with a new duration.
+     * @param id - The ID of the notification to restart.
+     * @param options - Whether to unshift the notification to the front of the queue.
+     * @param options.duration - The new duration for the notification. If not provided, the original duration will be used.
+     * @param options.unshift - If true, the notification will be moved to the front of the queue. Default is false.
+     */
+    restart: (id: string, options?: {
+        duration?: number;
+        unshift?: boolean;
+    }) => NeoNotificationQueued;
+    /**
+     * Clears all notifications from the stack.
+     */
+    clear: () => void;
+}
+export interface NeoNotificationProviderContext {
+    register: (service: NeoNotificationStackService) => void;
+    unregister: (id: NeoNotificationStackService['id']) => void;
+    get: (id?: NeoNotificationStackService['id']) => NeoNotificationStackService | undefined;
+}
+export declare function setNeoNotificationProviderContext(context: NeoNotificationProviderContext): NeoNotificationProviderContext;
+export declare function getNeoNotificationProviderContext(): NeoNotificationProviderContext;
+export declare function useNotificationService(id?: NeoNotificationStackService['id']): NeoNotificationStackService;
+export {};

package/dist/floating/notification/neo-notification-provider.model.js

@@ -0,0 +1,18 @@
+import { getContext, setContext } from 'svelte';
+import { NeoErrorNotificationServiceNotFound } from '../../utils/error.utils.js';
+const NeoNotificationProviderContextSymbol = Symbol('NeoNotificationProviderContext');
+export function setNeoNotificationProviderContext(context) {
+    return setContext(NeoNotificationProviderContextSymbol, context);
+}
+export function getNeoNotificationProviderContext() {
+    return getContext(NeoNotificationProviderContextSymbol);
+}
+export function useNotificationService(id) {
+    const context = getNeoNotificationProviderContext();
+    if (!context)
+        throw new NeoErrorNotificationServiceNotFound();
+    const service = context.get(id);
+    if (!service)
+        throw new NeoErrorNotificationServiceNotFound(id);
+    return service;
+}

package/dist/floating/notification/neo-notification-stack.model.d.ts

@@ -0,0 +1,48 @@
+import type { SvelteMap } from 'svelte/reactivity';
+import type { NeoNotificationPlacement } from '../common/neo-placement.model.js';
+import type { NeoNotification, NeoNotificationQueued, NeoNotificationStackDirections } from './neo-notification.model.js';
+import type { NeoPortalProps } from '../portal/neo-portal.model.js';
+export interface NeoNotificationStackProps<Tag extends keyof HTMLElementTagNameMap = 'ol'> extends Pick<NeoNotification, 'duration' | 'restartOnTouch' | 'pauseOnHover' | 'progressProps' | 'actionProps' | 'closeProps' | 'containerProps' | 'close' | 'loading' | 'progress' | 'elevation' | 'blur' | 'color' | 'rounded' | 'tinted' | 'filled' | 'borderless' | 'before' | 'after'> {
+    children?: NeoNotification['render'];
+    /**
+     * Unique identifier for the notification stack.
+     */
+    id?: string;
+    ref?: HTMLElementTagNameMap[Tag];
+    tag?: Tag;
+    queue?: SvelteMap<NonNullable<NeoNotificationQueued['id']>, NeoNotificationQueued>;
+    paused?: boolean;
+    hovered?: boolean;
+    focused?: boolean;
+    expand?: boolean;
+    delay?: number;
+    max?: number;
+    /**
+     * If true, notifications can be dragged to dismiss them.
+     * @default true
+     */
+    draggable?: boolean;
+    /**
+     * If true, notifications can be swiped to dismiss them.
+     * @default true
+     */
+    swipeable?: boolean;
+    /**
+     * The fraction of the notification stack height/width that must be scrolled before the notification is considered dismissed.
+     * @default 3 (1/3 of the stack height/width)
+     */
+    threshold?: number | {
+        x: number;
+        y: number;
+    };
+    /**
+     * The offset in pixels to apply when stacking notifications.
+     * @see expand
+     * @default 16
+     */
+    stagger?: number;
+    placement?: NeoNotificationPlacement;
+    direction?: NeoNotificationStackDirections;
+    portal?: boolean;
+    portalProps?: NeoPortalProps;
+}

package/dist/floating/notification/neo-notification-stack.model.js

@@ -0,0 +1 @@
+export {};

package/dist/floating/notification/neo-notification.model.d.ts

@@ -0,0 +1,271 @@
+import type { Snippet } from 'svelte';
+import type { NeoButtonProps } from '../../buttons/neo-button.model.js';
+import type { NeoCloseButtonProps } from '../../buttons/neo-close-button.model.js';
+import type { NeoProgressBarProps } from '../../progress/neo-progress-bar.model.js';
+import type { BorderRadiusInput } from '../../utils/border.utils.js';
+import type { Color } from '../../utils/colors.utils.js';
+import type { HTMLNeoBaseElement, HTMLTagProps, SvelteEvent } from '../../utils/html-element.utils.js';
+import type { BlurElevation, BlurElevationString, PositiveShadowElevation, PositiveShadowElevationString } from '../../utils/shadow.utils.js';
+export declare const NeoNotificationStackDirection: {
+    readonly Up: "up";
+    readonly Down: "down";
+};
+export type NeoNotificationStackDirections = (typeof NeoNotificationStackDirection)[keyof typeof NeoNotificationStackDirection];
+export declare const NeoNotificationStatus: {
+    /**
+     * The notification is pending and will be displayed in the queue.
+     */
+    readonly Pending: "pending";
+    /**
+     * The notification has been dismissed by the user.
+     */
+    readonly Dismissed: "dismissed";
+    /**
+     * The notification has been cancelled by programmatic action.
+     */
+    readonly Cancelled: "cancelled";
+    /**
+     * The notification duration has expired.
+     */
+    readonly Expired: "expired";
+};
+export type NeoNotificationStatuses = (typeof NeoNotificationStatus)[keyof typeof NeoNotificationStatus];
+export declare const NeoNotificationType: {
+    /**
+     * The notification is an info message.
+     */
+    readonly Info: "info";
+    /**
+     * The notification is a warning message.
+     */
+    readonly Warning: "warning";
+    /**
+     * The notification is an error message.
+     */
+    readonly Error: "error";
+    /**
+     * The notification is a success message.
+     */
+    readonly Success: "success";
+    /**
+     * The notification is a default message.
+     */
+    readonly Default: "default";
+};
+export type NeoNotificationTypes = (typeof NeoNotificationType)[keyof typeof NeoNotificationType];
+export declare const NeoNotificationEvent: {
+    /**
+     * The notification has changed its status.
+     */
+    readonly Status: "status";
+    /**
+     * The notification content has changed.
+     */
+    readonly Update: "update";
+    /**
+     * The notification timeout has been paused.
+     */
+    readonly Paused: "paused";
+    /**
+     * The notification timeout has been resumed or restarted.
+     */
+    readonly Restart: "restart";
+    /**
+     * The notification has been hidden either by queue eviction or if the max visible queue size was reached.
+     */
+    readonly Hidden: "hidden";
+    /**
+     * The notification has been show, either by being added to the queue or if an earlier notification was dismissed.
+     */
+    readonly Visible: "visible";
+};
+export type NeoNotificationEvents = (typeof NeoNotificationEvent)[keyof typeof NeoNotificationEvent];
+export type NeoNotificationBlur = BlurElevation | BlurElevationString;
+export type NeoNotificationElevation = PositiveShadowElevation | PositiveShadowElevationString;
+export type NeoNotificationClickResult = NeoNotificationStatuses | false | undefined | void;
+export interface NeoNotification {
+    /**
+     * A function that renders the notification content.
+     */
+    render?: Snippet<[NeoNotificationQueued]>;
+    /**
+     * Optional snippets to run before and after the notification is queued.
+     */
+    before?: Snippet<[NeoNotificationQueued]>;
+    /**
+     * Optional snippets to run after the notification is de-queued.
+     */
+    after?: Snippet<[NeoNotificationQueued]>;
+    /**
+     * Unique identifier for the notification.
+     */
+    id?: string;
+    /**
+     * The type of the notification.
+     */
+    type?: NeoNotificationTypes;
+    /**
+     * The title of the notification.
+     */
+    title?: string;
+    /**
+     *  The subtitle of the notification.
+     */
+    subtitle?: string;
+    /**
+     * The content of the notification.
+     */
+    content?: string;
+    /**
+     * Whether the notification is currently loading.
+     *
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Whether the notification has a progress bar.
+     * Defaults to an indeterminate progress bar if true.
+     *
+     * @default false
+     */
+    progress?: boolean;
+    /**
+     * Whether the notification has a close button.
+     *
+     * @default true
+     */
+    close?: boolean;
+    /**
+     * Duration in milliseconds for which the notification will be displayed.
+     * If not specified, the notification will remain until manually dismissed.
+     *
+     * @default 0 (indefinite)
+     */
+    duration?: number;
+    /**
+     * If true, the notification will be restarted when the user interacts with it (e.g., hover, click, touch).
+     * @default true
+     */
+    restartOnTouch?: boolean;
+    /**
+     * If true, notifications timeout will be paused while the user hovers over the notification.
+     * @default true
+     */
+    pauseOnHover?: boolean;
+    /**
+     * The shadow elevation of the notification.
+     *
+     * @default 1
+     */
+    elevation?: NeoNotificationElevation;
+    /**
+     * The blur level to apply to the notification backdrop (0 to 5).
+     *
+     * @default 1
+     */
+    blur?: NeoNotificationBlur;
+    /**
+     * Text color to use for the notification.
+     */
+    color?: Color | CSSStyleDeclaration['color'];
+    /**
+     * If true, the notification will have a rounded border.
+     */
+    rounded?: BorderRadiusInput;
+    /**
+     * Tints the notification with the current color.
+     */
+    tinted?: boolean;
+    /**
+     * Fills the notification background.
+     */
+    filled?: boolean;
+    /**
+     * Whether to remove the border from the notification.
+     */
+    borderless?: boolean;
+    /**
+     * Event handler that fires when the notification state changes.
+     *
+     * State changes can include:
+     * - status changes (e.g., from pending to dismissed)
+     * - visibility changes (e.g., when the notification is shown or hidden)
+     * - timeout changes (e.g., when the notification is paused, resumed, or restarted)
+     */
+    onChange?: (event: NeoNotificationEvents, item: NeoNotificationQueued) => void;
+    /**
+     * Props to pass to the notification container element.
+     */
+    containerProps?: Omit<HTMLNeoBaseElement, 'children'> & HTMLTagProps;
+    /**
+     * Optional progress bar properties to display a progress bar within the notification.
+     */
+    progressProps?: NeoProgressBarProps;
+    /**
+     * Optional action button properties to display an action button within the notification.
+     */
+    actionProps?: Omit<NeoButtonProps, 'onclick'> & {
+        onclick?: (e: SvelteEvent<MouseEvent>, checked?: boolean) => NeoNotificationClickResult | Promise<NeoNotificationClickResult>;
+    };
+    /**
+     * Optional close button properties to display a close button within the notification.
+     */
+    closeProps?: NeoCloseButtonProps;
+}
+export interface NeoNotificationDeQueued extends NeoNotification {
+    /**
+     * Unique identifier for the notification.
+     */
+    id: NonNullable<NeoNotification['id']>;
+    /**
+     * The notification's current status.
+     */
+    status: NeoNotificationStatuses;
+    /**
+     * The timestamp when the notification was added to the queue.
+     */
+    added: number;
+    /**
+     * The timestamp when the item was paused in the queue.
+     */
+    paused?: number;
+    /**
+     * The timestamp when the notification was shown (either by being added to the queue or if an earlier notification was dismissed).
+     */
+    visible?: number;
+    /**
+     * The timestamp when the notification was hidden (either by dismissal or if the max queue size was reached).
+     */
+    hidden?: number;
+    /**
+     * The timestamp when the notification was removed from the queue.
+     */
+    removed?: number;
+}
+export interface NeoNotificationQueued extends NeoNotificationDeQueued {
+    /**
+     * The notification's timeout reference.
+     */
+    timeout?: ReturnType<typeof setTimeout>;
+    /**
+     * The promise that resolves when the notification is de-queued.
+     */
+    promise: Promise<NeoNotificationDeQueued>;
+    /**
+     * Force the notification to be de-queued with the specified status.
+     * @param status
+     */
+    cancel: (status?: NeoNotificationStatuses) => NeoNotificationDeQueued;
+    /**
+     * Update the notification with new properties while in the queue.
+     * @param update
+     */
+    update: (update: Omit<NeoNotification, 'id'>) => NeoNotificationQueued;
+    /**
+     * Restart the notification's duration.
+     */
+    restart: (options?: {
+        duration?: number;
+        unshift?: boolean;
+    }) => NeoNotificationQueued;
+}

package/dist/floating/notification/neo-notification.model.js

@@ -0,0 +1,70 @@
+export const NeoNotificationStackDirection = {
+    Up: 'up',
+    Down: 'down',
+};
+export const NeoNotificationStatus = {
+    /**
+     * The notification is pending and will be displayed in the queue.
+     */
+    Pending: 'pending',
+    /**
+     * The notification has been dismissed by the user.
+     */
+    Dismissed: 'dismissed',
+    /**
+     * The notification has been cancelled by programmatic action.
+     */
+    Cancelled: 'cancelled',
+    /**
+     * The notification duration has expired.
+     */
+    Expired: 'expired',
+};
+export const NeoNotificationType = {
+    /**
+     * The notification is an info message.
+     */
+    Info: 'info',
+    /**
+     * The notification is a warning message.
+     */
+    Warning: 'warning',
+    /**
+     * The notification is an error message.
+     */
+    Error: 'error',
+    /**
+     * The notification is a success message.
+     */
+    Success: 'success',
+    /**
+     * The notification is a default message.
+     */
+    Default: 'default',
+};
+export const NeoNotificationEvent = {
+    /**
+     * The notification has changed its status.
+     */
+    Status: 'status',
+    /**
+     * The notification content has changed.
+     */
+    Update: 'update',
+    /**
+     * The notification timeout has been paused.
+     */
+    Paused: 'paused',
+    /**
+     * The notification timeout has been resumed or restarted.
+     */
+    Restart: 'restart',
+    /**
+     * The notification has been hidden either by queue eviction or if the max visible queue size was reached.
+     */
+    Hidden: 'hidden',
+    /**
+     * The notification has been show, either by being added to the queue or if an earlier notification was dismissed.
+     */
+    Visible: 'visible',
+};

package/dist/floating/notification/neo-simple-notification.model.d.ts

@@ -0,0 +1,14 @@
+import type { NeoNotificationItemProps } from './neo-notification-item.model.js';
+import type { NeoNotification } from './neo-notification.model.js';
+import type { NeoProgressHTMLElement } from '../../progress/neo-progress.model.js';
+import type { HTMLNeoBaseElement } from '../../utils/html-element.utils.js';
+export interface NeoSimpleNotificationProps<Tag extends keyof HTMLElementTagNameMap = 'div'> extends Omit<HTMLNeoBaseElement, 'children'>, Pick<NeoNotificationItemProps, 'before' | 'after' | 'item' | 'index' | 'restartOnTouch' | 'progress' | 'loading' | 'close' | 'rounded' | 'progressProps' | 'actionProps' | 'closeProps' | 'onCancel'> {
+    /**
+     * Optional content to display below the notification content.
+     */
+    children?: NeoNotification['render'];
+    ref?: HTMLElement;
+    bar?: NeoProgressHTMLElement;
+    height?: HTMLElement['offsetHeight'];
+    tag?: Tag | keyof HTMLElementTagNameMap;
+}

package/dist/floating/notification/neo-simple-notification.model.js

@@ -0,0 +1 @@
+export {};

package/dist/floating/portal/NeoPortal.svelte

@@ -1,30 +1,33 @@
 <script lang="ts">
-  import type { Snippet } from 'svelte';
-
   import type { NeoPortalProps } from './neo-portal.model.js';
 
   import { mount, unmount } from 'svelte';
 
   import { getNeoPortalContext } from './neo-portal-context.svelte.js';
+  import NeoPortalTarget from './NeoPortalTarget.svelte';
 
-  const { enabled = false, children, props: _props, outro = true, target = document.body, anchor, ...rest }: NeoPortalProps = $props();
+  const { enabled = false, children, outro = true, target = document.body, anchor, ...rest }: NeoPortalProps = $props();
 
   const portalContext = getNeoPortalContext();
 
   let component: ReturnType<typeof mount>;
   $effect.pre(() => {
     if (!children || !enabled) return;
-    component = mount(children, { target, anchor: anchor ?? portalContext?.ref, props: _props, ...rest });
+
+    component = mount(NeoPortalTarget, {
+      target,
+      anchor: anchor ?? portalContext?.ref,
+      props: { children },
+      ...rest,
+    });
 
     return () => {
       if (!component) return;
       unmount(component, { outro });
     };
   });
-
-  const snippet = $derived(children as Snippet<[typeof _props]>);
 </script>
 
-{#if !enabled && snippet}
-  {@render snippet(_props)}
+{#if !enabled && children}
+  {@render children()}
 {/if}

package/dist/floating/portal/NeoPortalTarget.svelte

@@ -0,0 +1,7 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+
+  const { children }: { children: Snippet } = $props();
+</script>
+
+{@render children?.()}

package/dist/floating/portal/NeoPortalTarget.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    children: Snippet;
+};
+declare const NeoPortalTarget: import("svelte").Component<$$ComponentProps, {}, "">;
+type NeoPortalTarget = ReturnType<typeof NeoPortalTarget>;
+export default NeoPortalTarget;

package/dist/floating/portal/neo-portal-context.svelte.d.ts

@@ -5,7 +5,7 @@ export declare class NeoPortalContext {
     get id(): string;
     get ref(): HTMLElement | undefined;
     get open(): number;
-    get placement(): NeoDialogPlacement;
+    get placement(): NeoDialogPlacement | undefined;
     constructor(id: string);
     updateRef(ref?: HTMLElement): void;
     openDialog(id: string, placement: NeoDialogPlacement): void;

package/dist/floating/portal/neo-portal.model.d.ts

@@ -1,10 +1,9 @@
 import type { mount, Snippet } from 'svelte';
-export type NeoPortalChildren<Props extends Record<string, any>, Exports extends Record<string, any>> = Parameters<typeof mount<Props, Exports>>[0];
-export type NeoPortalMountOptions<Props extends Record<string, any>, Exports extends Record<string, any>> = Parameters<typeof mount<Props, Exports>>[1];
+export type NeoPortalMountOptions = Pick<Parameters<typeof mount>[1], 'target' | 'anchor' | 'context' | 'intro'>;
 export interface NeoPortalUnmountOptions {
     outro?: boolean;
 }
-export type NeoPortalProps<Props extends Record<string, any> = Record<string, any>, Exports extends Record<string, any> = Record<string, any>> = {
+export type NeoPortalProps = {
     enabled?: boolean;
-    children: NeoPortalChildren<Props, Exports> | Snippet<[NeoPortalMountOptions<Props, Exports>['props']]>;
-} & Partial<NeoPortalMountOptions<Props, Exports>> & NeoPortalUnmountOptions;
+    children?: Snippet;
+} & Partial<NeoPortalMountOptions> & NeoPortalUnmountOptions;

package/dist/floating/tooltips/NeoPopConfirm.svelte

@@ -27,6 +27,7 @@
     tooltipRef = $bindable(),
     triggerRef = $bindable(),
     open = $bindable(false),
+    position = $bindable(),
     target,
     openDelay,
     hoverDelay,
@@ -124,6 +125,7 @@
   bind:ref={tooltipRef}
   bind:triggerRef
   bind:open
+  bind:position
   keepOpenOnFocus
   closeOnDismiss={closable}
   {tooltip}

package/dist/floating/tooltips/NeoPopConfirm.svelte.d.ts

@@ -1,4 +1,4 @@
 import type { NeoPopConfirmProps } from './neo-pop-confirm.model.js';
-declare const NeoPopConfirm: import("svelte").Component<NeoPopConfirmProps, {}, "disabled" | "loading" | "open" | "triggerRef" | "tooltipRef">;
+declare const NeoPopConfirm: import("svelte").Component<NeoPopConfirmProps, {}, "loading" | "disabled" | "open" | "position" | "triggerRef" | "tooltipRef">;
 type NeoPopConfirm = ReturnType<typeof NeoPopConfirm>;
 export default NeoPopConfirm;