@dvcol/neo-svelte 1.1.2 → 1.2.0

package/dist/floating/notification/NeoNotificationStack.svelte

@@ -0,0 +1,345 @@
+<script lang="ts">
+
+  import type { NeoNotificationStackService } from './neo-notification-provider.model.js';
+  import type { NeoNotificationStackProps } from './neo-notification-stack.model.js';
+  import type { NeoNotification, NeoNotificationDeQueued, NeoNotificationQueued } from './neo-notification.model.js';
+
+  import { debounce } from '@dvcol/common-utils/common/debounce';
+  import { getUUID } from '@dvcol/common-utils/common/string';
+  import { onDestroy, onMount } from 'svelte';
+  import { SvelteMap } from 'svelte/reactivity';
+
+  import { NeoNotificationPlacements } from '../common/neo-placement.model.js';
+  import { getNeoNotificationProviderContext } from './neo-notification-provider.model.js';
+  import { NeoNotificationEvent, NeoNotificationStackDirection, NeoNotificationStatus } from './neo-notification.model.js';
+  import NeoNotificationItem from './NeoNotificationItem.svelte';
+  import NeoPortal from '../portal/NeoPortal.svelte';
+  import { NeoErrorNotificationMissingId, NeoErrorNotificationNotFound } from '../../utils/error.utils.js';
+
+  let {
+    // Snippets
+    children,
+    before,
+    after,
+
+    // Stats
+    id = $bindable<string>(getUUID()),
+    ref = $bindable(),
+    tag = 'ol',
+    queue = $bindable(new SvelteMap<NonNullable<NeoNotificationQueued['id']>, NeoNotificationQueued>()),
+    paused = $bindable(false),
+    hovered = $bindable(false),
+    focused = $bindable(false),
+    expand,
+    delay = 900,
+    max = expand ? 6 : 3,
+
+    // Item Props
+    duration = 10000,
+    pauseOnHover = true,
+    draggable = true,
+    swipeable = false,
+    threshold = { x: 3, y: 2 },
+    restartOnTouch,
+    progress,
+    loading,
+    close = true,
+
+    // Style
+    elevation = 1,
+    blur,
+    color,
+    filled,
+    tinted,
+    rounded,
+    borderless,
+
+    // Position
+    placement = NeoNotificationPlacements.BottomEnd,
+    direction,
+    portal,
+
+    // Other props
+    portalProps,
+    containerProps,
+    actionProps,
+    closeProps,
+    ...rest
+  }: NeoNotificationStackProps = $props();
+
+  let active = $state(false);
+
+  const debounceActive = debounce((value: boolean) => {
+    active = value;
+  }, delay);
+
+  function setActive(value: boolean): void {
+    if (value) {
+      active = true;
+      debounceActive.cancel();
+    } else {
+      debounceActive(value);
+    }
+  }
+
+  const expanded = $derived(expand ?? active);
+
+  const reverse = $derived.by(() => {
+    if (direction !== undefined) return direction === NeoNotificationStackDirection.Down;
+    return placement?.startsWith('top');
+  });
+
+  const visible = $derived.by(() => {
+    if (!queue) return [];
+    return Array.from(queue.values()).map((item, index) => ({ item, index })).slice(-max);
+  });
+
+  export function add(item: NeoNotification): NeoNotificationQueued {
+    const { promise, resolve } = Promise.withResolvers<NeoNotificationDeQueued>();
+
+    const response: NeoNotificationDeQueued = {
+      id: getUUID(),
+      duration,
+      ...item,
+      status: NeoNotificationStatus.Pending,
+      added: Date.now(),
+    };
+
+    const queued: NeoNotificationQueued = {
+      ...response,
+      promise,
+      cancel: (status = NeoNotificationStatus.Cancelled) => {
+        if (!response.id) throw new NeoErrorNotificationMissingId();
+        const item = queue.get(response.id);
+        if (!item) throw new NeoErrorNotificationNotFound(id);
+        queue.delete(response.id);
+        response.removed = Date.now();
+        response.status = status;
+        resolve(response);
+        item.onChange?.(NeoNotificationEvent.Status, item);
+        return response;
+      },
+      update: (update: Omit<NeoNotification, 'id'>): NeoNotificationQueued => {
+        if (!response.id) throw new NeoErrorNotificationMissingId();
+        const item = queue.get(response.id);
+        if (!item) throw new NeoErrorNotificationNotFound(response.id);
+        if ('id' in update) delete update.id; // Ensure we don't overwrite the id
+        Object.assign(item, update);
+        item.onChange?.(NeoNotificationEvent.Update, item);
+        if (item.duration) return item.restart();
+        return item;
+      },
+      restart: (options: { duration?: number; unshift?: boolean } = {}): NeoNotificationQueued => {
+        if (!response.id) throw new NeoErrorNotificationMissingId();
+        const item = queue.get(response.id);
+        if (!item) throw new NeoErrorNotificationNotFound(response.id);
+
+        clearTimeout(item.timeout);
+        item.duration = options.duration ?? item.duration ?? duration;
+
+        // Remove the item from the queue before restarting
+        if (options.unshift) queue.delete(response.id);
+
+        if (item.duration && !paused) {
+          item.timeout = setTimeout(() => {
+            if (!item.id) throw new NeoErrorNotificationMissingId();
+            if (!queue?.has(item.id)) return;
+            item.cancel(NeoNotificationStatus.Expired);
+          }, item.duration);
+        }
+
+        // Re-add the item to the queue
+        if (options.unshift) queue.set(response.id, item);
+        item.onChange?.(NeoNotificationEvent.Restart, item);
+        return item;
+      },
+    };
+
+    queue.set(response.id, queued);
+    return queued.restart();
+  }
+
+  export function get(uuid: string): NeoNotificationQueued | undefined {
+    return queue.get(uuid);
+  }
+
+  export function remove(uuid: string, status = NeoNotificationStatus.Cancelled): NeoNotificationDeQueued {
+    const item = queue.get(uuid);
+    if (!item) throw new NeoErrorNotificationNotFound(uuid);
+    return item.cancel(status);
+  }
+
+  export function update(uuid: string, update: Omit<NeoNotification, 'id'>): NeoNotificationQueued {
+    const item = queue.get(uuid);
+    if (!item) throw new NeoErrorNotificationNotFound(uuid);
+    return item.update(update);
+  }
+
+  export function restart(uuid: string, options?: { duration?: number; unshift?: boolean }): NeoNotificationQueued {
+    const item = queue.get(uuid);
+    if (!item) throw new NeoErrorNotificationNotFound(uuid);
+    return item.restart(options);
+  }
+
+  export function clear(): void {
+    queue?.forEach(item => item.cancel(NeoNotificationStatus.Cancelled));
+    queue?.clear();
+  }
+
+  const resume = debounce(() => queue?.forEach((item) => {
+    if (!item.paused || !item.duration) return;
+    // restart the item with a duration base on item.added and item.paused
+    item.restart({ duration: item.duration - (item.paused - item.added), unshift: false });
+    delete item.paused;
+  }), delay);
+
+  export function pause(_paused: boolean = true): void | Promise<void> {
+    paused = _paused;
+
+    if (!_paused) return resume();
+    queue?.forEach((item) => {
+      if (!item.timeout) return;
+      if (!(item.pauseOnHover ?? pauseOnHover)) return;
+      item.paused = Date.now();
+      item.onChange?.(NeoNotificationEvent.Paused, item);
+      clearTimeout(item.timeout);
+    });
+  }
+
+  let swiped = $state(false);
+  const debounceSwiped = debounce((swipe: boolean) => {
+    swiped = swipe;
+  }, 600);
+
+  const context = getNeoNotificationProviderContext();
+
+  onMount(() => {
+    if (!context) return;
+    context.register({ id, add, get, remove, update, pause, restart, clear } satisfies NeoNotificationStackService);
+  });
+
+  onDestroy(() => {
+    context.unregister(id);
+  });
+</script>
+
+<NeoPortal enabled={portal} {...portalProps}>
+  <svelte:element
+    bind:this={ref}
+    this={tag}
+    id="neo-notification-stack-${id}"
+    data-max={max}
+    data-visible={visible.length}
+    data-setsize={queue.size}
+    aria-live="polite"
+    aria-relevant="additions text"
+    aria-atomic="false"
+    data-placement={placement}
+    class:neo-notification-stack={true}
+    {...rest}
+  >
+    {#each visible as { item, index }, i (item?.id)}
+      <NeoNotificationItem
+        tag={['ul', 'ol'].includes(tag) ? 'li' : 'div'}
+
+        index={i}
+        posinset={index + 1}
+        setsize={queue.size}
+        visible={visible.length}
+
+        expand={expanded}
+        {reverse}
+        {draggable}
+        {swipeable}
+        {placement}
+        {threshold}
+        {swiped}
+
+        {item}
+        {before}
+        {after}
+        {children}
+
+        {restartOnTouch}
+        {progress}
+        {loading}
+        {close}
+
+        {elevation}
+        {blur}
+        {color}
+        {filled}
+        {tinted}
+        {rounded}
+        {borderless}
+
+        {containerProps}
+        {actionProps}
+        {closeProps}
+
+        onChange={(state) => {
+          hovered = state.hovered;
+          focused = state.focused;
+          setActive(hovered || focused);
+          pause(hovered || focused);
+        }}
+
+        onCancel={({ event }) => {
+          if (!(event instanceof WheelEvent)) return;
+          swiped = true;
+          debounceSwiped.cancel();
+          debounceSwiped(false);
+        }}
+      />
+    {/each}
+  </svelte:element>
+</NeoPortal>
+
+<style>.neo-notification-stack {
+  z-index: var(--neo-z-index-layer-top, 2000000000);
+  width: 0;
+  height: 0;
+  list-style: none;
+  pointer-events: none;
+  position: fixed;
+  margin: var(--neo-notification-margin, var(--neo-gap));
+  display: flex;
+  flex-direction: column;
+}
+.neo-notification-stack[data-placement=center] {
+  inset: 0;
+  margin: var(--neo-notification-margin, auto);
+}
+.neo-notification-stack[data-placement^=top], .neo-notification-stack[data-placement=right-start], .neo-notification-stack[data-placement=left-start] {
+  top: 0;
+  bottom: auto;
+}
+.neo-notification-stack[data-placement^=bottom], .neo-notification-stack[data-placement=right-end], .neo-notification-stack[data-placement=left-end] {
+  top: auto;
+  bottom: 0;
+}
+.neo-notification-stack[data-placement^=left], .neo-notification-stack[data-placement=bottom-start], .neo-notification-stack[data-placement=top-start] {
+  right: auto;
+  left: 0;
+  align-items: start;
+}
+.neo-notification-stack[data-placement^=right], .neo-notification-stack[data-placement=bottom-end], .neo-notification-stack[data-placement=top-end] {
+  right: 0;
+  left: auto;
+  align-items: end;
+}
+.neo-notification-stack[data-placement=right], .neo-notification-stack[data-placement=left] {
+  top: 0;
+  bottom: 0;
+  margin-top: var(--neo-notification-margin-top, auto);
+  margin-bottom: var(--neo-notification-margin-bottom, auto);
+}
+.neo-notification-stack[data-placement=top], .neo-notification-stack[data-placement=bottom] {
+  right: 0;
+  left: 0;
+  margin-right: var(--neo-notification-margin-right, auto);
+  margin-left: var(--neo-notification-margin-left, auto);
+}
+.neo-notification-stack[data-placement=top], .neo-notification-stack[data-placement=bottom], .neo-notification-stack[data-placement=center] {
+  align-items: center;
+}</style>

package/dist/floating/notification/NeoNotificationStack.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { NeoNotificationStackProps } from './neo-notification-stack.model.js';
+import type { NeoNotification, NeoNotificationDeQueued, NeoNotificationQueued } from './neo-notification.model.js';
+declare const NeoNotificationStack: import("svelte").Component<NeoNotificationStackProps<"ol">, {
+    add: (item: NeoNotification) => NeoNotificationQueued;
+    get: (uuid: string) => NeoNotificationQueued | undefined;
+    remove: (uuid: string, status?: "cancelled") => NeoNotificationDeQueued;
+    update: (uuid: string, update: Omit<NeoNotification, "id">) => NeoNotificationQueued;
+    restart: (uuid: string, options?: {
+        duration?: number;
+        unshift?: boolean;
+    }) => NeoNotificationQueued;
+    clear: () => void;
+    pause: (_paused?: boolean) => void | Promise<void>;
+}, "id" | "ref" | "hovered" | "focused" | "paused" | "queue">;
+type NeoNotificationStack = ReturnType<typeof NeoNotificationStack>;
+export default NeoNotificationStack;

package/dist/floating/notification/NeoSimpleNotification.svelte

@@ -0,0 +1,304 @@
+<script lang="ts">
+  import type { NeoSimpleNotificationProps } from './neo-simple-notification.model.js';
+  import type { SvelteEvent } from '../../utils/html-element.utils.js';
+
+  import { scaleHeight, scaleWidth } from '@dvcol/svelte-utils/transition';
+  import { scale } from 'svelte/transition';
+
+  import NeoButton from '../../buttons/NeoButton.svelte';
+  import NeoCloseButton from '../../buttons/NeoCloseButton.svelte';
+  import { NeoNotificationStatus, NeoNotificationType } from './neo-notification.model.js';
+  import NeoIconCircleLoading from '../../icons/NeoIconCircleLoading.svelte';
+  import NeoIconError from '../../icons/NeoIconError.svelte';
+  import NeoIconInfo from '../../icons/NeoIconInfo.svelte';
+  import NeoIconSuccess from '../../icons/NeoIconSuccess.svelte';
+  import NeoIconWarning from '../../icons/NeoIconWarning.svelte';
+  import NeoProgressBar from '../../progress/NeoProgressBar.svelte';
+  import { quickDurationProps } from '../../utils/transition.utils.js';
+
+  let {
+    // Snippet
+    children,
+    before,
+    after,
+
+    // State
+    ref = $bindable(),
+    bar = $bindable(),
+    height = $bindable(0),
+
+    tag = 'div',
+
+    item,
+    index,
+
+    restartOnTouch,
+    progress,
+    loading,
+    close = true,
+
+    // Style
+    rounded,
+
+    // Events
+    onCancel,
+
+    // Other Props
+    progressProps,
+    actionProps,
+    closeProps,
+    ...rest
+  }: NeoSimpleNotificationProps = $props();
+
+  const onCloseButton = (event: SvelteEvent<MouseEvent>) => {
+    item.cancel(NeoNotificationStatus.Dismissed);
+    onCancel?.({ item, index, event });
+  };
+
+  const showClose = $derived(item.close ?? close);
+  const showAction = $derived(!!(item.actionProps || actionProps));
+  const showAfter = $derived(showClose || showAction || (item.after ?? after));
+  const showBefore = $derived((item.loading ?? loading) || !!(item.before ?? before) || (item.type && item.type !== NeoNotificationType.Default));
+
+  const notifSize = $derived.by(() => {
+    if (height <= 48) return 'sm';
+    if (height <= 96) return 'md';
+    return 'lg';
+  });
+
+  const iconSize = $derived.by(() => {
+    if (height <= 48) return '1.25rem';
+    if (height <= 96) return '2rem';
+    return '2.5rem';
+  });
+
+  const onActionButton = async (event: SvelteEvent<MouseEvent>, checked?: boolean) => {
+    const cb = item.actionProps?.onclick ?? actionProps?.onclick;
+    const result = await cb?.(event, checked);
+    if (item.paused && (item.restartOnTouch ?? restartOnTouch)) item.paused = item.added;
+    if (!result) return;
+    item.cancel(typeof result === 'string' ? result : NeoNotificationStatus.Dismissed);
+    onCancel?.({ item, index, event });
+  };
+
+  const defaultProgress = $derived.by(() => {
+    const duration = item.duration ? (item.duration - (Date.now() - item.added)) : undefined;
+    const step = duration ? (100 / (duration / 1000)) : undefined;
+    return {
+      step,
+      tick: 1000,
+      autoStart: { pending: !duration },
+      autoComplete: true,
+    };
+  });
+</script>
+
+<svelte:element
+  this={tag}
+  bind:this={ref}
+  bind:offsetHeight={height}
+  class:neo-notification={true}
+  class:neo-rounded={rounded}
+  aria-live="polite"
+  role={item.type === NeoNotificationType.Error ? 'alert' : 'status'}
+  data-size={notifSize}
+  {...rest}
+>
+  <div class="neo-notification-body" class:neo-after={showAfter}>
+    {#if showBefore}
+      <div class="neo-notification-before" transition:scaleWidth={quickDurationProps}>
+        {#if item.loading ?? loading}
+          <NeoIconCircleLoading size={iconSize} />
+        {:else if (item.before ?? before)}
+          {@render (item.before ?? before)?.(item)}
+        {:else if item.type === NeoNotificationType.Error}
+          <NeoIconError size={iconSize} stroke={1} />
+        {:else if item.type === NeoNotificationType.Warning}
+          <NeoIconWarning size={iconSize} stroke={1} />
+        {:else if item.type === NeoNotificationType.Info}
+          <NeoIconInfo size={iconSize} stroke={1} />
+        {:else if item.type === NeoNotificationType.Success}
+          <NeoIconSuccess size={iconSize} stroke={1} />
+        {/if}
+      </div>
+    {/if}
+    <div class="neo-notification-text" class:neo-before={showBefore}>
+      {#if item.title}
+        <div class="neo-notification-title" transition:scaleHeight={quickDurationProps}>{item.title}</div>
+      {/if}
+      {#if item.subtitle}
+        <div class="neo-notification-subtitle" transition:scaleHeight={quickDurationProps}>{item.subtitle}</div>
+      {/if}
+      {#if item.content}
+        <div class="neo-notification-content" transition:scaleHeight={quickDurationProps}>
+          {item.content}
+        </div>
+      {/if}
+      {#if children}
+        {@render children(item)}
+      {/if}
+      {#if item.progress ?? progress}
+        <div class="neo-notification-progress" transition:scaleHeight={quickDurationProps}>
+          <NeoProgressBar
+            bind:ref={bar}
+            glass
+            elevation={-1}
+            aria-label="Notification progress"
+            {...defaultProgress}
+            {...progressProps}
+            {...item.progressProps}
+          />
+        </div>
+      {/if}
+    </div>
+  </div>
+  {#if showAfter}
+    <div class="neo-notification-actions" class:neo-rounded={rounded} transition:scaleWidth={quickDurationProps}>
+      {#if item.close ?? close}
+        <NeoCloseButton
+          rounded
+          text
+          size="md"
+          inline={notifSize === 'sm'}
+          aria-label="Close notification"
+          title="Close"
+          transition={{ use: scale, props: quickDurationProps }}
+          {...closeProps}
+          {...item.closeProps}
+          onclick={onCloseButton}
+          class={['neo-notification-close-button', closeProps?.class, item.closeProps?.class]}
+        />
+      {/if}
+      {#if item.actionProps || actionProps}
+        <NeoButton
+          {rounded}
+          elevation={0}
+          aria-label="Notification action"
+          title="Action"
+          label="action"
+          transition={{ use: scale, props: quickDurationProps }}
+          {...actionProps}
+          {...item.actionProps}
+          class={['neo-notification-action-button', actionProps?.class, item.actionProps?.class]}
+          onclick={onActionButton}
+        />
+      {/if}
+      {#if item.after ?? after}
+        {@render (item.after ?? after)?.(item)}
+      {/if}
+    </div>
+  {/if}
+</svelte:element>
+
+<style>.neo-notification {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  height: 100%;
+}
+.neo-notification :global(.neo-notification-close-button) {
+  margin-bottom: auto;
+  opacity: 0.5;
+  transition: opacity 0.3s ease;
+  transition-duration: 0.6s;
+}
+.neo-notification.neo-rounded {
+  padding-inline: var(--neo-gap-3xs, 0.3125rem);
+}
+.neo-notification-body {
+  display: flex;
+  flex: 1 1 auto;
+  width: max-content;
+  min-width: min(10rem, 80vw);
+  max-width: calc(100vw - 2rem);
+  padding: var(--neo-notification-padding, var(--neo-gap-xxs, 0.5rem));
+  transition: padding 0.3s ease;
+}
+.neo-notification-body.neo-after {
+  padding-inline-end: 0;
+}
+.neo-notification-before {
+  display: flex;
+  flex: 0 0 auto;
+  align-items: center;
+  justify-content: center;
+  margin-inline-end: var(--neo-gap-xxs, 0.5rem);
+}
+.neo-notification-text {
+  display: flex;
+  flex: 1 1 auto;
+  flex-direction: column;
+  gap: var(--neo-gap-5xs, 0.125rem);
+}
+.neo-notification-title {
+  font-weight: var(--neo-font-weight-xxl, 800);
+}
+.neo-notification-subtitle {
+  font-weight: var(--neo-font-weight-md, 500);
+}
+.neo-notification-subtitle, .neo-notification-content {
+  color: var(--neo-notification-color, var(--neo-text-color-secondary));
+  font-size: var(--neo-font-size-sm, 0.875rem);
+  line-height: var(--neo-line-height-sm, 1.25rem);
+  white-space: pre-line;
+}
+.neo-notification-title, .neo-notification-subtitle, .neo-notification-content {
+  transition: color 0.6s ease;
+}
+.neo-notification:hover :global(.neo-notification-close-button), .neo-notification:active :global(.neo-notification-close-button), .neo-notification:focus :global(.neo-notification-close-button), .neo-notification:focus-within :global(.neo-notification-close-button), .neo-notification:focus-visible :global(.neo-notification-close-button) {
+  opacity: 1;
+  transition-delay: 0s;
+}
+.neo-notification:hover .neo-notification-subtitle,
+.neo-notification:hover .neo-notification-content, .neo-notification:active .neo-notification-subtitle,
+.neo-notification:active .neo-notification-content, .neo-notification:focus .neo-notification-subtitle,
+.neo-notification:focus .neo-notification-content, .neo-notification:focus-within .neo-notification-subtitle,
+.neo-notification:focus-within .neo-notification-content, .neo-notification:focus-visible .neo-notification-subtitle,
+.neo-notification:focus-visible .neo-notification-content {
+  color: var(--neo-notification-color-highlight, var(--neo-text-color-secondary-highlight));
+}
+.neo-notification-actions {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  justify-content: space-around;
+  height: 100%;
+  min-height: var(--neo-notification-height, strech);
+  transition: margin 0.3s ease;
+}
+.neo-notification-actions.neo-rounded :global(.neo-notification-close-button) {
+  margin-right: var(--neo-gap-xxs, 0.25rem);
+}
+.neo-notification-progress {
+  margin-top: var(--neo-gap-4xs, 0.25rem);
+}
+.neo-notification[data-size=sm] :global(.neo-notification-close-button) {
+  margin-left: var(--neo-gap-4xs, 0.25rem);
+}
+.neo-notification[data-size=sm].neo-rounded :global(.neo-notification-close-button) {
+  margin-top: auto;
+  margin-right: var(--neo-gap-5xs, 0.125rem);
+}
+.neo-notification[data-size=md] .neo-notification-body {
+  padding: var(--neo-notification-padding, var(--neo-gap-xxs, 0.5rem) var(--neo-gap-xs, 0.625rem));
+}
+.neo-notification[data-size=md] .neo-notification-body.neo-after {
+  padding-inline-end: 0;
+}
+.neo-notification[data-size=md] .neo-notification-before {
+  margin-inline-end: var(--neo-gap-xs, 0.625rem);
+}
+.neo-notification[data-size=lg] :global(.neo-close-button) {
+  --neo-btn-close-margin: var(--neo-gap-xs, 0.625rem);
+}
+.neo-notification[data-size=lg] .neo-notification-body {
+  padding: var(--neo-notification-padding, var(--neo-gap-xxs, 0.5rem) var(--neo-gap-sm, 0.75rem));
+}
+.neo-notification[data-size=lg] .neo-notification-body.neo-after {
+  padding-inline-end: 0;
+}
+.neo-notification[data-size=lg] .neo-notification-before {
+  margin-inline-end: var(--neo-gap-sm, 0.75rem);
+}</style>

package/dist/floating/notification/NeoSimpleNotification.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { NeoSimpleNotificationProps } from './neo-simple-notification.model.js';
+declare const NeoSimpleNotification: import("svelte").Component<NeoSimpleNotificationProps<"div">, {}, "height" | "ref" | "bar">;
+type NeoSimpleNotification = ReturnType<typeof NeoSimpleNotification>;
+export default NeoSimpleNotification;

package/dist/floating/notification/index.d.ts

@@ -0,0 +1,8 @@
+export * from './neo-notification-stack.model.js';
+export * from './neo-notification.model.js';
+export * from './neo-simple-notification.model.js';
+export type * from './neo-notification-provider.model.js';
+export { useNotificationService } from './neo-notification-provider.model.js';
+export { default as NeoNotificationProvider } from './NeoNotificationProvider.svelte';
+export { default as NeoNotificationStack } from './NeoNotificationStack.svelte';
+export { default as NeoSimpleNotification } from './NeoSimpleNotification.svelte';

package/dist/floating/notification/index.js

@@ -0,0 +1,7 @@
+export * from './neo-notification-stack.model.js';
+export * from './neo-notification.model.js';
+export * from './neo-simple-notification.model.js';
+export { useNotificationService } from './neo-notification-provider.model.js';
+export { default as NeoNotificationProvider } from './NeoNotificationProvider.svelte';
+export { default as NeoNotificationStack } from './NeoNotificationStack.svelte';
+export { default as NeoSimpleNotification } from './NeoSimpleNotification.svelte';